Java学习_0710 基本语法

7月10日：知识点_1.常量：是不会改变的值的变量，声明之前加final比如：

                                                        final float f=3.1415926f;

                                                        命名规范一般大写，通常声明为static

                                       2.’\r’的长度为1位，因为它是转义字符。

                   需要背的    1.八种基本、原始数据类型：

                                                 整数：byte、short、int、long

                                                 浮点数：float、double

                                                 字符类型：char

                                                 布尔类型：boolean

                                               2.强类型：数据的类型有唯一性，语法规定严格，比如Java，.net

                                                 弱类型：语法规定不严格，比如：Html、js

                                                 Java中动态加载机制（是一个类）：在程序运行过程中加入一个类

                                                 API：应用程序编程接口（从哪个包下找到类来使用）

                                                 JRE：Java运行时的环境

                                                 RDE：集成开发环境（也就是Java的开发工具）

                                                缓存：

                   预习：main：1.继承

1.1：java只支持单继承,通过关键字extends完成继承

1.2：是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系

1.3：继承中：子类完全拥有（非私有）父类的全部方法和属性

                            同时，也可以定义自己的方法和属性

                            也可以重写父类的方法

1.4：例如：class A extends B     类A继承类B

1.5：在子类中调用父类的方法时候用super.(方法)。

            super()总是引用直接父类的构造方法

1.6：例子：结果输出”asdad”

 

1.7：注意：子类中不能直接访问父类中的私有成员

用到super()与否，都是先调用超类构造函数，再调用子类构造函数

如果没用到super(),将调用超类系统默认的或没有参数的构造函数

 

                                               2.多态：

2.1：定义：是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

2.2：多态的两种方式：重载（overloading）和重写（Overriding）

         重载：是java实现面向对象的多态性机制的一种方式。

同一个类中多个方法有相同的名字，不同的参数列表，这种情况称为方法重载。

当重载方法被调用时，编译器根据参数的类型和数量来确定实际调用哪个重载方法的版本

重载的实现：

参数顺序不同

参数类型不同

参数个数不同

注意：返回值不同不能实现重载!

重写：在子类中定义某方法与其父类有相同的名称和参数，且方法的返回值类型与抛出异常的类型各自与父类的一致，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了

在子类中调用父类被重写的方法使用super关键词。

                                               3．static

3.1：静态方法（static）：类名.方法名。如：Animal.eat()；

3.2：静态块：在类被调用到内存后就开始执行的它和创建对象或者main方法都没有关系，区分是构造方法和静态块执行

比如：

static {

                   System.out.println("static block");

         }

3.3：静态属性：所有此类实例共享此静态属性，也就是说在类加载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。

                                   类名.属性名调用

                                               4.this

4.1: this可以看成是一个变量。每一个对象都会自动保存一个变量this，它指向这个对象自己。

4.2:使用this在构造函数中调用本类其它重载的构造函数:

       this()或者this(参数列表)

4.3:方法中调用属性: this.实例变量名

                                               5.包

5.1:包在较大的范围内实现了OOP的封装机制，它把一组类和接口封装在一个包之内，这为管理大量的类和接口提供了方便，也有利于这些类和接口的安全

5.2:包名一般小写,放在文件开头:如com.公司名.项目

                  

 

预习需要背的：

访问修饰符	包外	包外子类	包内	类内
public	是	是	是	是
protected	否	是	是	是
friendly(默认)	否	否	是	是
private	否	否	否	是

 

 

                                               6.类的访问修饰符

                                                        6.1：默认，没有修饰符：只能被包内的其他类访问

                                                                 public：可以被类外的任何类访问

                                                                 final：不能被其他类继承

                                                                 abstract：抽象类：声明方法的存在而不去实现它的类

                                                                                     抽象方法(只有方法的声明，没有具体的实现）

                                                                                     注意：能包含非抽象的方法和变量

                                                                                                不能被实例化

                                                                                                必须在子类中给出具体实现

                                                                                                不能定义抽象构造函数

                                                                                                不能定义抽象静态方法

所有抽象类的子类必须实现抽象函数，或者自己也声明成抽象类

                                                        6.2抽象类：一个类的一个或多个方法为抽象方法时

该类为一个抽象类的子类，并且没有实现所有抽象方法时。

实现一个接口，并且没有实现所有抽象方法时。

定义一个抽象类类型的变量，指向一个其子类的实例。

例如：

 

 

                                               7.接口：关键字：interface接口就是需要由其它类实现的行为模板

                                                                 类一次只能继承一个类但可以实现多个接口

                                                                 不能有任何具体的方法实现，默认为public abstract

                                                                 也可定义常量：默认为：public static final                                                            

                                                                

                                                                 接口的实现：用implements关键字

                                                                                             注意：@多个接口中方法相同时：

                                                                                                         同名不同参，方法重载

                                                                                                         完全相同，实现其中一个

                                                                                                         只是返回类型不同，没有办法解决

                                                                                                           @定义完后必须在某个类中对这个接口的方法进行具体化，重新定义接口的所有方法，这时的方法不能是抽象的

@extends关键字实现父接口，一个接口可以有多个父接口，子接口将继承所有父接口的所有属性和方法

     @属性必须是public static final修饰的(系统默认)   

            @方法系统默认为public abstract的，没有方法体

     @接口可以没有任何接口体，但大括号不能省略

@实现的方法的访问控制符必须显式地使用public修饰

@一个类声明实现某个接口后必须实现该接口的全部方法

 

                                               8.抽象类和接口的区别：抽象类：@不能创建对象

@如果一个类中一个方法为抽象方法，则这个类必须为abstract抽象类

@继承抽象类的类在类中必须实现抽象类中的抽象方法.

@抽象类中可以有抽象方法，也可有非抽象方法。抽象方法不能为private.

@间接继承抽象类的类可以不给出抽象方法的定义。

                                                                                                      接口： 接口中的所有数据均为static和

final,即静态常量。尽管可以不用

这两个关键字修饰 ，但必须给常

量赋初值。

@方法均为public，在实现接口类中，实现方法必须为public关键字。

@使用public来修饰接口，则接口必须与文件名相同

                                               抽象类与接口都用于抽象，但是抽象类可以有自己的部分实现，而接

口则完全是一个标识(同时有多重继承的功能)

 

数据类型	封封装类	数据类型	封封装类
boolean	Boolean	float	Float
byte	Byte	int	Integer
char	Character	long	Long
double	Double	short	Short

9.封装类：

 

 

 

 

 

                                              

                                              

 

 

 

 

 

 

10.内部类：在类中定义的类。目的是为了解决Java中存在的没有多继承这个问题。

                          建立一个内部类时，其对象就拥有了与外部类对象之间的一种关系，这是通过一个特殊的this reference形成的，使得内部类对象可以随意的访问外部类中所有的成员

                          使用方式：直接在类中定义类或者在方法中定义类

                          类中定义类：

 

方法中定义类:

 

这里面定义了一个名为IContent的接口