【Java笔记】Week03 -- 面向对象的深入接触

写在前面的部分

本周主要深入学习了面向对象的深入部分-----匿名对象、封装、this关键字、static、工具类、代码块、继承、方法重写、final关键字。

笔记内容--面向对象

1.匿名对象

a. 定义

没有名字的对象（一般直接new一个对象即可，没有对象名称）

b. 意义：

意义: 节省代码，并且很多情况下是针对某个方法只需要调用一次的情况下。

c. 匿名对象的使用及对比：

public class Demo1 {public static void main(String[] args) {//下面为正常创建对象并输出信息Person person = new Person();person.initPerson();person.speak();//下面为几种匿名对象的使用方法new Person("diffo",22).speak();    //直接new 一个对象 通过构造方法对成员变量赋值initPerson(new Person()).speak();  //匿名对象也可以作为方法参数传递}static Person initPerson(Person person){person.name="diffo";person.age = 22;return person;}}class Person{String name;int age;Person(){}Person(String nameParm,int ageParm){name = nameParm;age = ageParm;}void initPerson(){name="diffo";age = 22;}void speak(){System.out.println("speak!: "+name+" . "+age);}}

d.总结：

匿名对象可以调用方法，也可以给成员变量赋值。 同时也可以作为方法的参数进行传递。
主要的作用就是节省代码量，使代码结构更优雅。（某些情况下，我们只需要这个对象进行一次操作，那么我们就可以定义为匿名对象）

2.封装

a. 概念：

1.概念: 隐藏对象的属性和细节，仅对外提供公共的方法进行访问。

b. private:

(1) : 当类的成员变量使用private 修饰符修饰，那么就不可以直接访问到该成员变量.（类外无法调用该成员变量）

(2) : 当使用private 修饰的成员变量或者成员方法，仅能在本类中使用

(3) : private 对于main 方法的修饰，也是可以产生作用的.

c. javaBean:

他的所有成员变量都使用private 进行修饰，并且对外提供可访问的设置值和获取值的set,get方法。不同的应用场景，可能命名不同，数据库的应用中称为POJO类.

//java beanclass Person{private String name;private int age;void setName(String nameParm){name = nameParm;}String getName(){return name;}void setAge(int ageParm){age = ageParm;}int getAge(){return age;}void speak(){System.out.println(name+" . "+age);}public static void main(String[] args){Person person = new Person();person.setName("diffo");person.setAge(30);person.speak();}}class DemoBean{static void main(String[] args){Person person = new Person();person.setName("diffo");person.setAge(30);person.speak();}}

d. 附加内容（main方法的细节）：

（1） 每个类中都可以存在main方法，但是当执行的时候，会优先查看public 的class 中是否有main 方法.

（2） 如果没有public 的class, 那么会按照文件名优先查找类中的main方法

（3） 必须定义为public.

3.优先原则

对于一个类的成员方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理.

4.this关键字

a. 定义：

代表了当前对象的引用（可以理解为，当前谁来调用，那么方法中的this 就代表谁）.

b. 注意事项：

可以加在成员变量之前或者方法前面（一般用于构造方法或者get，set方法中）

class Person{String name;int age;、、用于构造方法中给成员变量赋初值Person(String name,int age){this.name = name;this.age = age;}//用于set方法中void setName(String name) {this.name = name;}}

5.static关键字

a.随着类加载而加载

static修饰的变量会在静态方法区中来保存

b. 优先于对象创建

加载类的时候会先取出静态方法区中的变量和方法，然后在创建对象

c. 被类的所有对象共享

静态的成员变量会保存在该class的静态方法区中，所以每个对象看到的都是同一份.

d. 可以通过类名来访问也可以通过对象名来访问
e. 推荐通过类名来访问
f. 静态的成员，一般称为类相关的成员。
g. static 修饰符既可以修饰成员变量，也可以修饰成员方法。 且修饰之后，就可以通过类名来直接访问到。
h.this变量在静态方法中不可以使用
i.静态方法中只能访问静态成员变量和静态方法。
  非静态方法既可以访问静态成员和方法(不建议)也可以访问非静态成员和方法。

6.工具类

a. 概念：

全部都是静态的方法。所以可以通过 类名.functionName() 方式来访问。

b. 注意事项 ：

工具类定义出来一般是让人直接使用，不需要创建对象调用，所以一般采用将默认构造方法前加private处理

private Person() { }

工具类可以再API中查阅，建议经常使用工具类的方法，而不是习惯性的写一个方法来使用

7.代码块

a. 概念：

 使用{} 括起来的代码，称为代码块

b. 分类

（1）局部代码块 ： 

int i = 0;while(1) {    int i ;  //报错  因为前面已经定义了一个i    int j = 0;}j = 1;  //  报错  因为离开代码块之后  j已经被销毁

特点：

局部代码块限定了变量的生命周期，变量在局部代码块中定义的，那么出来局部代码块之后，就访问不到了。在局部代码块中定义的变量，在出了代码块之后，内存就会释放掉。
作用:

 主要就是节约内存.

  （2） 构造代码块

概念  :
类中方法外出现，每次调用构造方法的时候，都会优先先调用构造代码块。11.11.

public class Demo1 {public static void main(String[] args) {Person p = new Person();System.out.println("--------------");Person p1 = new Person();}}class Person{{System.out.println("构造代码块");}Person() {System.out.println("默认构造");}}/*构造代码块默认构造--------------构造代码块默认构造*/

特点：

每创建一次对象，都会在创建之前调用构造代码块

作用：

如果存在很多重载的构造方法，而且每个里面需要执行相同的逻辑，那么就可以考虑将这些代码提取到构造代码块中来执行。（比如一些构造方法中的赋值操作可以提取到构造代码块中）
让我们代码结构更简练。增强了维护性.

（3） 构造代码块

概念：

类中方法外出现，但是用static 来进行修饰。

package org.westos;public class Demo1 {public static void main(String[] args) {Person p = new Person();System.out.println("--------------");Person p1 = new Person();}}class Person{static{System.out.println("静态代码块");}{System.out.println("构造代码块");}Person() {System.out.println("默认构造");}}/*静态代码块    //此段说明静态代码块发生在类加载的时候构造代码块默认构造--------------构造代码块默认构造*/

特点：

随着类加载的时候执行（在创建对象之前执行，只运行一次）

用处:

适用于整个软件的生命周期中，只需要执行一次的业务逻辑代码。

8.继承

a. 特点：

（1）子类继承父类，继承父类的成员变量和成员方法。但是他们各自拥有的各自的成员变量，所以他们的值，并不会继承。
（2）对于父类中的私有成员变量和私有方法，子类是无法继承的。

（3）只支持单继承，但是可以支持多层继承

继承是相互叠加的，子类继承的时候，会递归似的寻找父类中是否还存在继承，会继承整个层级直到最根部类的属性和方法。

（4）对于构造方法是无法继承的。

但是有办法可以调用父类的构造方法。（super关键字）

（5）子类可以直接访问和使用父类继承的非私有的成员变量或方法

（6）如果子类中定义了和父类中相同名字的成员变量或方法，会优先访问子类的该变量

b. 优点：

（1） 提高了代码的复用性
（2） 提高了代码的维护性

c. 缺点：

类的耦合性增强了。

9.方法重写

a. 存在于继承关系中，子类中定义的方法和父类中的方法完全一样的时候(返回值类型父子类关系是可以的),我们在通过子类对象访问该方法的时候，就会调用到子类的方法，而不是调用父类的方法。

b. 注意事项：

（1） 子类不能重写父类的私有方法.

（2） 子类重写父类方法的时候，提供的访问权限不能更低.

（3） 子类覆盖父类方法，如果父类是静态方法的话，子类也必须是静态方法才可以成功覆盖，也就是重写。

c. 对比

方法重载: 仅返回值不同是不能重载的。必须参数列表不同。
方法重写: 返回值类型(父子类关系是可以的) 要求返回值类型也要相同的.

10.super关键字

a.  继承关系中，如果子类如果想要访问到父类中的同名变量，我们需要加上super关键字来获取.

class A {    A() { }}class B extends B {    B() {    super();//调用父类的构造方法    }}

b. 继承中构造方法的调用

特点：

（1）创建子类对象的时候，一定会优先去创建父类的对象。 因为要创建父类对象，所以就需要去调用到父类的构造方法.
（2）对于我们所有的类的构造方法的第一行，第一行在我们没有自己添加this(...)或者super(...)的情况下都会去帮我们默认的添加super()

注意事项：

（1） 如果父类中不存在默认的构造，子类依然要创建对象，那么子类就需要显示的指明调用的是哪一个父类对象，才能保证父类对象创建的成功。

（2）一定要保证父类对象的创建成功.

（3）构造方法的第一行，如果我们添加了自己调用的this(...),或者super(...), 系统就不会为我们默认的添加super().
（4）我们的this(...)或者super(...) 必须放到第一行。二者只能有其一。

11.final关键字

a. final修饰类

final如果修饰一个类，该类不能被继承.

b. final修饰类的成员变量

该成员变量的值不可修改。（可以在静态初始化给该成员变量赋值）

初始化时机：

a.构造代码块中可以进行初始化

b.构造方法中可以进行初始化

c.定义成员变量的时候，可以直接进行初始化.

注意一点: 这三种方式同时只能用一种。

在大多数的场景下，我们的final成员变量都会配合public static 一起使用.