Day01 面向对象 继承 抽象类 接口 static

1.匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。

2.类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。

父类抽取出了共性的内容，子类可以在父类基础上扩展新的属性与方法。

子类拥有父类的所有属性与方法，无需重新定义。并且可以直接使用非私有的父类成员。

1.1 -子类中访问父类成员方法特点

l 子父类中成员方法的特点

当在程序中通过对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法

_面向对象_构造方法

1).任何的类中都有构造方法，如果我们不定义，系统会自动添加一个

默认（公有、无参、什么都不做的）构造方法。

class Student{

public Student(){

}

}

2).每次"创建对象"时，都会自动执行"构造方法"。

3).构造方法的作用：初始化成员属性；

4).构造方法的定义格式：

访问修饰符 构造方法名(同类名)(形参){

}

Super关键字:::当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关键字super来完成。

一般的访问不需要使用this关键字，但有些情况必须使用：

1).在某个方法内，局部变量覆盖了成员变量，此时要访问别覆盖的成员变量，

必须使用：this.成员变量名

class Student{

String name;

public void setName(String name){

this.name = name;

}

}

_面向对象_this关键字

1).this是每个类中都有的一个成员变量，由编译器自动添加的；

2).每当创建一个对象时，JVM会自动将这个对象的"引用"赋值给这个this变量；

3).它表示：引用当前对象的.....(成员属性、成员方法等)；

也就是，通过this可以访问"当前对象"的"成员"；

class Student{

private String name;

public void setName(String name){

this.name = name;

}

public void getName(){

return this.name;//表示：当前对象的，name成员属性

}

}

6.1.charAt(int index):获取这个字符串中某个索引位置上的字符

5.boolean endsWith(String str):判断当前字符串是否以str结尾；

6.int indexOf(String str):查找str在当前字符串中的位置。如果没找到，返回-1

 

注意：以上对字符串操作的所有方法，都不能改变原字符串，都是生成一个新的字符串；

1. 在每次创建子类对象时，父类的class文件也会进入内存中。目的在于子类对象中包含了其对应的父类存储空间，便可以包含其父类对象的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。

代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

1.2 8.抽象类&抽象方法的使用

抽象类无法直接创建对象，只能被子类继承后，创建子类对象。

子类需要继承抽象父类并完成最终的方法实现细节(即重写方法，完成方法体)。而此时，方法重写不再是加强父类方法功能，而是父类没有具体实现，子类完成了具体实现，我们将这种方法重写也叫做实现方法。

1.3 抽象类常见疑惑

l 抽象类一定是个父类，因为抽象类时不断抽取共性需求而来的。

l 抽象类中是可以不定义抽象方法的，此时仅仅是不让该类创建对象，用于某些特殊的设计需要。

l 设计时由具体类抽取出抽象类，而开发阶段应该先定义抽象父类，再根据不同需求由父类定义子类。

l  }

l 03.面向对象_继承_this和super关键字

l  1).this:

l  1).任何类中都有一个this成员变量；

l  2).当创建对象时，由JVM为其赋值，赋值为当前对象的引用；

l  3).通过this可以访问本类的成员属性、成员方法、构造方法；

l  2).super:

l  1).任何类中都有一个super成员变量；

l  2).当创建对象时，由JVM为其赋值，赋值为父类对象的引用；

l  3).通过super，可以访问父类中的成员变量、成员方法、构造方法；

1.1 this与super

1.1.1 子类对象产生

在每次创建子类对象时，父类的class文件也会进入内存中。目的在于子类对象中包含了其对应的父类存储空间，便可以包含其父类对象的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。

8.面向对象_继承_子类覆盖父类的成员方法（方法重写）

1).有时候，子类需要保留父类的功能(方法名)，但需要做不同的事情。

这时，子类就可以定义一个跟父类那个方法"一模一样"的方法，用来覆盖父类中的原方法。

这种形式就叫：方法的重写

2).重写规则：

1).子类方法的"访问修饰符"必须跟父类相同，或者比父类更宽；

从宽到窄：public,protected,(默认)

2).子类方法的：返回值类型，方法名，形参列表必须与父类方法完全相同

3).可以使用@Override强制重写验证；Eclipse会按照重写的语法规则检查你的方法。

3).重写的注意事项：

1).父类的"私有方法"由于不能被继承，所以谈不上被重写；

2).静态方法不能被重写；

4).重写的作用：

保留了父类的功能(相同的方法名)，而且实现了子类特有的行为(子类方法内特有的行为)。

1.

接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

1.4 2.接口中成员的特点

1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解static与final关键字

2、接口中可以定义方法，方法也有固定的修饰符，public abstract

3、接口不可以创建对象。

4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

5.由于犬分为很多种类，他们吼叫和吃饭的方式不一样，在描述的时候不能具体化，也就是吼叫和吃饭的行为不能明确。当描述行为时，行为的具体动作不能明确，这时，可以将这个行为写为抽象行为，那么这个类也就是抽象类。

可是当缉毒犬有其他额外功能时，而这个功能并不在这个事物的体系中。这时可以让缉毒犬具备犬科自身特点的同时也有其他额外功能，可以将这个额外功能定义接口中。

6.相同点:

l 都位于继承的顶端,用于被其他类实现或继承;

l 都不能直接实例化对象;

l 都包含抽象方法,其子类都必须覆写这些抽象方法;

区别:

l 抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;

l 一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

l 抽象类为继承体系中的共性内容,接口为继承体系中的扩展功能

1.1 抽象类&抽象方法的使用

抽象类无法直接创建对象，只能被子类继承后，创建子类对象。

子类需要继承抽象父类并完成最终的方法实现细节(即重写方法，完成方法体)。而此时，方法重写不再是加强父类方法功能，而是父类没有具体实现，子类完成了具体实现，我们将这种方法重写也叫做实现方法。

抽象类是拥有构造方法的，其存在的意义在于对自身进行初始化，供其子类使用。

二者的选用:

l 优先选用接口,尽量少用抽象类;

l 需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

3.父类引用指向子类对象就是多态的定义格式。同一个父类的方法会被不同的子类重写为各自的具体实现。在调用方法时，调用的为各个子类重写后的方法。

父类类型  变量名 = new 子类类型();

变量名.方法名();

此时，虽然该变量指向的是子类对象，但表现为一个父类的形态，可以调用一切父类的方法，子类特有的方法将不能调用。

1.5 多态调用注意事项

l 成员变量编译看父类中是否存在,不存在编译失败

l 成员变量运行父类中的变量

l 成员方法编译看父类中是否存在,不存在编译失败

l 成员方法运行子类重写的方法

多态的弊端: 不能调用子类的特有方法

.面向对象_多态_多态中成员的访问_总结

1.多态时，访问的任何成员，在父类中必须存在；否则编译错误(不能访问子类特有成员)

2.多态时，访问被子类覆盖的成员属性--访问的是父类的 编译看左边，运行看左边 Person p = new Student();

System.out.println(p.num1);

多态时，访问被子类重写的成员方法--访问的是子类的      编译看左边，运行看右边 Person p = new Student();

p.show();//访问的是子类的

多态时，访问的静态方法--访问的是父类的 编译看左边，运行看左边

1.6 static特点

static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。

static修饰的成员被多个对象共享。

static修饰的成员属于类，但是会影响每一个对象。

被static修饰的成员又叫类成员，不叫对象的成员。

1.7 2.静态代码块

静态代码块是定义在成员位置，使用static修饰的代码块。

特点：

l 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

l 该类不管创建多少对象，静态代码块只执行一次。

l 可用于给静态变量赋值，用来给类进行初始化。

public class Person {

private String name;

private int age;

//静态代码块

static{

System.out.println("静态代码块执行了");

}

}

四种访问权限修饰符

l 要想仅能在本类中访问使用private修饰；

l 要想本包中的类都可以访问不加修饰符即可；

l 要想本包中的类与其他包中的子类可以访问使用protected修饰

l 要想所有包中的所有类都可以访问使用public修饰。

l 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

3.

04.面向对象_static关键字_注意实现_静态代码块00000000000000000000000000000000000000000000000

1).static关键字的注意事项：

1).一个类中的"静态成员"和"普通成员"分配内存空间的时机是不一样的。

"静态成员"无论任何情况下，都比"普通成员"先分配内存。

   "静态成员"是在"第一次使用这个类"的时候，就会被分配空间。

2).在静态的方法内，不能直接访问"非静态成员"；只能访问"静态成员"；

在普通的方法内，可以访问静态成员和普通成员；

3).在静态方法内，不能使用this和super关键字；（this和super是在创建对象时，JVM才会为其赋值）

2).静态成员如果使用"构造方法"初始化有些晚了。

可以使用静态代码块为静态成员属性初始化。

3).静态代码块是定义在"类体中"：

class Student{

static String schoolName;

static{

schoolName = "传智播客北京校区";

}

}

4).静态代码块只在"第一次使用这个类"的时候被执行一次，之后再也不会被执行了。

5).静态代码块的作用：初始化静态成员；

4.

一个问题：abstract关键字不能和哪些关键字共存？

1).final : 因为final类不能被继承，而abstract类就是被继承的；方法也是一样；所以冲突；

2).private : abstract方法就是被子类重写的。private的方法不能被继承，也就不能被重写，所以冲突；

3).static : static方法第一次使用这个类时就要被分配空间，abstract的方法没有方法体，无法被分配空间；所以冲突；

另一个问题：当对于"成员变量"，如果被修饰为static，很有可能也需要被修饰为final

class Student{

static final String schoolName = "传智播客北京校区";

}

1.1 接口概念

接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。

接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

请记住：一切事物均有功能，即一切事物均有接口。

1.1 接口中成员的特点

1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解static与final关键字

2、接口中可以定义方法，方法也有固定的修饰符，public abstract

3、接口不可以创建对象。

4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

1.8 Day04面向对象

这时就会想，那么我们能不能不创建对象，就可以调用方法呢？

static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。

static修饰的成员被多个对象共享。

static修饰的成员属于类，但是会影响每一个对象。

被static修饰的成员又叫类成员，不叫对象的成员。

2.静态代码块是定义在成员位置，使用static修饰的代码块。

特点：

l 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

l 该类不管创建多少对象，静态代码块只执行一次。

l 可用于给静态变量赋值，用来给类进行初始化。

l 3.要想仅能在本类中访问使用private修饰；

l 要想本包中的类都可以访问不加修饰符即可；

l 要想本包中的类与其他包中的子类可以访问使用protected修饰

l 要想所有包中的所有类都可以访问使用public修饰。

l 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

所以多态的存在意义(优点)为：

配合继承与方法重写提高了代码的复用性与扩展性，如果没有方法重写，则多态同样没有意义。

多态的弊端: 不能调用子类的特有方法

1. String str =new String(“hello”)  上面语句中变量str放在栈上, 用new创建出来的字符串对象放在堆上,而 hello 这个字面量是放在方法区的

第1章 四种访问权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，以下表来说明不同权限的访问能力：

	public	protected	空的(default)	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问

l 要想仅能在本类中访问使用private修饰；

l 要想本包中的类都可以访问不加修饰符即可；

l 要想本包中的类与其他包中的子类可以访问使用protected修饰

l 要想所有包中的所有类都可以访问使用public修饰。

l 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

l 什么时候使用内部类

在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。