Java-笔记3

一. 匿名对象
定义: 没有名字的对象。
意义: 节省代码，并且很多情况下是针对某个方法只需要调用一次的情况下。
匿名对象可以调用方法，也可以给成员变量赋值。 同时也可以作为方法的参数进行传递。
主要的作用就是节省代码量，使代码结构更优雅。

二. 封装
1.概念: 隐藏对象的属性和细节，仅对外提供公共的方法进行访问。
2.private
a. 当类的成员变量使用private 修饰符修饰，那么就不可以直接访问到该成员变量.
b. 当使用private 修饰的成员变量或者成员方法，仅能在本类中使用
c. private 对于main 方法的修饰，也是可以产生作用的.
javaBean:
是这样一类的类:
他的所有成员变量都使用private 进行修饰，并且对外提供可访问的设置值和获取值的set,get方法。不同的应用场景，可能命名
不同，数据库的应用中称为POJO类.
main方法细节:
a.每个类中都可以存在main方法，但是当执行的时候，会优先查看public 的class 中是否有main 方法.
b.如果没有public 的class, 那么会按照文件名优先查找类中的main方法
c.必须定义为public.

相关代码：

class 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();}}

结果为；diffo 30

        diffo 30

三. 优先原则:
优先原则: 对于一个类的成员方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理.
四. this 关键字
含义:
代表了当前对象的引用.
可以理解为，当前谁来调用，那么方法中的this 就代表谁。
对于成员变量可以区分出来的场景，this 可加也可以不加，实际效果相同。
但是对于实现javaBean/POJO 来说，我们建议都加上在setXXX,getXXX方法中.
this:
可以加在成员变量的前面来指定对应的引用，也可以加在成员方法的前面。

public class This{private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}

五. 初始化类成员变量的方式
a.在定义成员变量的同时进行赋值.

相关代码：

public class DemoClassTest{public static void main(String[] args){//在构造方法执行前进行赋值，并且该类每个实现的对象，都会被初始化为该值.//意义: 当我们真的需要一个类的所有对象某些成员变量的值一致的时候。Person person = new Person();person.entity = "Japan";person.showEntity();}}class Person{//改成员变量就不可被外部访问(外部: 类之外)int age=20;static String entity;void showEntity(){System.out.println("Entity:"+entity);}}

结果为：Entity:Japan

b.提供外界可访问到的方法，在方法中进行赋值.

相关代码：

public class DemoClassTest{public static void main(String[] args){//通过调用某个设置值的方法进行赋值,在对象创建完成之后//意义: 动态的修改成员变量的值.Person person2 = new Person();person2.getEntity(Java);person2.showEntity();}}class Person{String entity;void getEntity(String entity){this.entity=entity;}void showEntity(){System.out.println("Entity:"+entity);}}

结果为：Entiy:Java

c.通过构造方法进行赋值.

相关代码：

public class DemoClassTest{public static void main(String[] args){//构造方法中直接进行赋值.//意义： 可以在创建对象的同时进行赋值，同时还可以动态的指定设定的值是什么Person person1 = new Person(20);person1.outputAge();}}class Person{int age;Person(int age){this.age = age;}void outputAge(){System.out.println(this.age);}}

结果为：20

六. static
a.随着类加载而加载
静态方法区中来保存静态成员变量
b.优先于对象创建
Person.className = "java";
c.被类的所有对象共享
静态的成员变量会保存在该class的静态方法区中，所以每个对象看到的都是同一份.
d.可以通过类名来访问也可以通过对象名来访问。
效果是一样的。
e.推荐通过类名来访问
f.静态的成员，一般称为类相关的成员。
f.static 修饰符既可以修饰成员变量，也可以修饰成员方法。 且修饰之后，就可以通过类名来直接访问到。
g.this变量在静态方法中不可以使用
h.静态方法中只能访问静态成员变量和静态方法。
非静态方法既可以访问静态成员和方法也可以访问非静态成员和方法。
非静态虽然可以访问静态的方法，但是不建议这样做。
相关代码：

public class DemoStatic{public static void main(String[] args){Person person = new Person();Person.action();//Person.speak();/*person.name="ryan";System.out.println(new Person().name);System.out.println(Person.name);*/method();}static void method(){System.out.println("method");}}class Person{static String name = "diffo";static int age = 20;void speak(){System.out.println("speak:"+age);}static void action(){speak();}}

结果为：speak:20

        method

七. main方法.
修饰符 返回类型 方法名 (参数列表){

}
public static void main(String[] args){

}
public: 最大的一个访问权限，使得jvm能够成功调用
static: 类相关的，与对象无关. A.main([]);
public class A{
main(){
System.("");
}
}
void: 不需要返回值.
方法名: main
参数列表: 执行的时候，可以传递参数.
八. 工具类.
全部都是静态的方法。所以可以通过 类名.functionName() 方式来访问。
一般的话，都会对默认构造方法进行私有化处理，来防止别人使用时习惯性的创建对象来调用方法。
相关代码：

//工具类: 都是把其中的方法定义为staticpublic class MathUtil{//加法static int sum(int num1,int num2){return num1+num2;}public static void main(String[] args){System.out.println(MathUtil.sum(2,3));new User().getResult();}}class User{void getResult(){System.out.println(MathUtil.sum(2,3));}}

结果为：5

        5

九. 代码块
概念:
使用{} 括起来的代码，称为代码块
分类:
根据它位置和声明的不同，我们可以将代码块分为局部代码块，构造代码块，静态代码块，同步代码块(多线程涉及)
a. 局部代码块
限定了变量的生命周期，变量在局部代码块中定义的，那么出来局部代码块之后，就访问不到了。在局部代码块中定义的变量，
在出了代码块之后，内存就会释放掉。
作用: 主要就是节约内存.
局部代码块中定义的变量，虽然说作用域是局部的，但是如果存在外部嵌套的代码块，且在局部代码块定义之前就定义了某个变量，
那么在我们局部的代码块中就不可以定义相同名称的变量。
但是如果在局部代码块执行之后，去定义一个和局部代码块中相同名称的变量，是可以的。因为局部代码块中的变量已经失去了作用域范围。

相关代码：

public class Demo1{public static void main(String[] args){{int x=10;}int x = 20；System.out.println(x);}}

结果为：20

b.构造代码块
概念:
类中方法外出现，每次调用构造方法的时候，都会优先先调用构造代码块。
特点:
没创建一个对象，都会调用一次我们的构造代码块.
作用:
如果存在很多重载的构造方法，而且每个里面需要执行 相同的逻辑，那么就可以考虑将这些代码提取到构造代码块中来执行。
让我们代码结构更简练。增强了维护性.
使用场景其实不太多见。
c.静态代码块
概念:
类中方法外出现，但是用static 来进行修饰。
特点:
随着类加载的时候执行。
用处:
适用于整个软件的生命周期中，只需要执行一次的业务逻辑代码。
比如我们之后数据库的操作.

相关代码：

public class Demo2{static{System.out.println("demo2 静态代码块");}public static void main(String[] args){Person person = new Person();System.out.println("--------------------");Person person1 = new Person(20);}}class Person{int age;int[] num;static{System.out.println("调用了静态代码块");}{//构造代码块System.out.println("构造代码块");}//默认的构造方法Person(){System.out.println("默认构造");// 数组成员变量我们依次赋值}Person(int age){this.age = age;System.out.println("非默认构造"）；// 数组成员变量我们依次赋值}

}

结果为：demo2 静态代码块

                调用了静态代码块

构造代码块

默认构造

--------------------

构造代码块

非默认构造

二. 继承
特点
1. 子类继承父类，继承父类的成员变量和成员方法。但是他们各自拥有的各自的成员变量，所以他们的值，并不会继承。
2. 对于父类中的私有成员变量和私有方法，子类是无法继承的。
继承优点:
a.提高了代码的复用性
b.提高了代码的维护性
继承缺点:
a.类的耦合性增强了。
开发的原则:
高内聚，低耦合.
耦合: 类和类之间的关系
内聚: 自己独立完成某件事情的能力.
电视类: 品牌， 价格 ， 尺寸
手机类: 品牌， 价格 ， 尺寸, 操作系统
上层抽出来一个类： 电器类(品牌，价格，尺寸)

相关代码：

public class ExtendsDemo1{public static void main(String[] args){/*Father father = new Father();father.name="father";father.speak();*/Son son = new Son();son.setName("diffo");son.speak();}}class Father{private int age;private String name;void setAge(int age){this.age = age;}void setName(String name){this.name = name;}int getAge(){return age;}String getName(){return name;}void speak(){System.out.println("father speak:"+name);}}class Son extends Father{}

结果：father speak:diffo
3.只支持单继承，但是可以支持多层继承
继承是相互叠加的，子类继承的时候，会递归似的寻找父类中是否还存在继承，会继承整个层级直到最根部类的属性和方法。

相关代码：

public class ExtendsDemo2{public static void main(String[] args){GrandFather gFather = new GrandFather();gFather.speak();Father father = new Father();father.speak();father.eat();Son son = new Son();son.eat();son.sleep();son.speak();}}class GrandFather{void speak(){System.out.println("speak");}}class Father extends GrandFather{void eat(){System.out.println("eat");}}class Son extends Father{void sleep(){System.out.println("sleep");}}

结果为：speak
speak
eat
eat
sleep
speak

4.对于构造方法是无法继承的。
但是有办法可以调用父类的构造方法。
继承关系中访问成员变量:
a.不同名的成员变量
子类可以直接访问和使用父类继承的非私有的成员变量
b.同名的成员变量
优先原则: 如果子类中定义了和父类中相同名字的成员变量，会优先访问子类的该变量
如果想要依然访问到父类中的同名变量，我们需要加上super关键字来获取.
this: 当前对象的引用
super: 父类对象的引用
this: 可以访问到子类中的变量，也可以访问到父类中的变量
super: 访问父类中的变量

public class ExtendsDemo3{public static void main(String[] args){Son son = new Son();//System.out.println(son.num3);son.print();}}class Father{int num1 = 10;int num2 = 20;}class Son extends Father{int num3 = 30;int num1 = 40;//num1是子类中定义的一个和父类同名的变量。void print(){System.out.println(this.num1+" .. "+this.num2);System.out.println(super.num1+" .. "+super.num2);}}

结果为：40..20

10..20

继承关系中访问成员方法:
a.不同名的方法
子类可以直接调用到父类的方法
b.同名的方法
当父类和子类出现同名方法的时候(同名方法: 指的返回值类型(父子类关系是可以的)，方法名称以及方法接收的形参列表要一模一样)
在这种情况下:
当我们子类调用该方法时，会有优先原则的处理，就是会调用子类的该方法。
方法的重写:
存在于继承关系中，子类中定义的方法和父类中的方法完全一样的时候(返回值类型父子类关系是可以的),我们在通过子类对象来
访问该方法的时候，就会调用到子类的方法。
方法重写注意事项:
子类不能重写父类的私有方法.
子类重写父类方法的时候，提供的访问权限不能更低.

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

相关代码：

public class ExtendsDemo4{public static void main(String[] args){Son son = new Son();son.speak();}}class Father{static void speak(){System.out.println("father speak");}}class Son extends Father{void eat(){System.out.println("eat");this.speak();}static void speak(){System.out.println("son speak");}}

结果为：son speak

方法重载:
同一个类中，如果我们有多个相同方法名的方法，但是他们的形参列表是不同的，那么这种方式我们就称为方法的重载。

在调用的时候，jvm能够通过不同的形参来区分到我们到底调用的是哪个方法.

相关代码：

public class Practice{public static void main(String[] args){Son son = new Son();son.speak("joke");}}class Father{void speak(String name){System.out.println("father speak:"+name);}}class Son extends Father{void speak(int age){System.out.println("son speak:"+age);}}

结果为：father speak:joke

关于方法重写和方法重载的返回值约束:
方法重载: 仅返回值不同是不能重载的。必须参数列表不同。
方法重写: 返回值类型(父子类关系是可以的) 要求返回值类型也要相同的.
this: 可以访问子类的方法，也可以访问父类的方法。
super: 只能够访问父类的方法。

继承中构造方法的调用:
特点:
1. 创建子类对象的时候，一定会优先去创建父类的对象。 因为要创建父类对象，所以就需要去调用到父类的构造方法.
2. 对于我们所有的类的构造方法的第一行，第一行在我们没有自己添加this(...)或者super(...)的情况下都会去帮我们默认的添加
super()
如果父类中不存在默认的构造，子类依然要创建对象，那么子类就需要显示的指明调用的是哪一个父类对象，才能保证父类对象
创建的成功。
明确一点:
a.一定要保证父类对象的创建成功.
b.构造方法的第一行，如果我们添加了自己调用的this(...),或者super(...), 系统就不会为我们默认的添加super().
c.我们的this(...)或者super(...) 必须放到第一行.二者只能有其一.

相关代码：

public class ExtendsDemo5{public static void main(String[] args){Son son = new Son();System.out.println("-------------");}}class Father{/*Father(){System.out.println("father 默认构造");}*/Father(int num){System.out.println("father 有参构造");}}class Son extends Father{Son(){//super(10);this(10); //this(10), 所以就不会帮我们再去默认添加super(),System.out.println("son 默认构造");}Son(int num){super(10);//super(10); //第一行没有this或者super,就会帮我们添加super()System.out.println("son 有参构造");}}

结果为：father 有参构造

son 有参构造

son 默认构造

三. final关键字
a.final修饰类
final如果修饰一个类，该类不能被继承.
b.final修饰类的成员变量
该成员变量的值不可修改。
问题: 那么什么时候初始化这个值?
在对象创建之前都可以.
a.构造代码块中可以进行初始化
b.构造方法中可以进行初始化
c.定义成员变量的时候，可以直接进行初始化.
注意一点: 这三种方式同时只能用一种。
在大多数的场景下，我们的final成员变量都会配合public static 一起使用.

静态成员变量的初始化时机:a.在创建静态final成员变量的时候，直接进行初始化。b.在静态代码块中进行初始化.

相关代码：

public class FinalDemo1{public static void main(String[] args){Person person = new Person();    //rson.sayNum();}}class Person{//final 修饰成员变量，该值不可修改.static final int num;static{num = 10;}Person(){}void sayNum(){System.out.println(num);}}

结果为：10