Java面向对象

面向对象编程：OOP

初始面向对象

属性+方法=类

面向对象&面向过程

面向过程思想：步骤简单清晰，适合处理一些较为简单的问题
面向对象思想：分类的思维模式，首先解决问题需要哪些分类，对分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。适合处理复杂，需要多人协作的问题。

本质：以类的方式组织代码，以对象的形式组织（封装）数据。

抽象

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。（因为先想到要做什么（对象），再去找办法（类））。先有具体的对象，再去抽象出类（抽象出这些人的共同点）.就是在一堆人里，有一半是老师就抽象出一个类：老师。

从代码运行角度考虑是先有类。类是对象的模板（先找到共同点，确定一个类）先抽象出一个类：老师，再把那一堆人里是老师的封装出来。

三大特性：

1. 封装
2. 继承
3. 多态：同一种事物有多种形态（一个人生很多孩子，虽然每个孩子都长的不一样，但是都是你的孩子）

方法回顾和加深

方法的定义：

1. 修饰符
2. 返回类型
3. break：跳出switch，结束整体循环和return：结束方法，返回一个结果
4. 方法名：注意规范，见名知意
5. 参数列表：（参数类型，参数名），（int...b）可变参数
6. 异常抛出

方法的调用：

1. 静态方法：和类一起加载

2. 非静态方法：

   1. 不用类的非静态方法，只能实例化（new Student().say()）,new+类名+方法名 。Student student=new Student（），再调用 student。say（）
   2. 一个类的两个方法，两个都是静态或者非静态，则上面的可以直接调用，如果上面的是静态，下面是非静态，上面就不可以直接调用下面的方法。
      没看懂
      

3. 形参和实参

4. 值传递和引用传递

5. this关键字

对象的创建分析

类是一种抽象的数据类型，他是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
对象是抽象概念的具体实例

练习：先写一个方法，再在main方法里调用，赋值，输出

点击查看代码

package com.xin.oop;import com.xin.oop.Demo3.Pet;//一个项目应该只存一个main方法
public class Applicaton {public static void main(String[] args) {Pet dog = new Pet();dog.name = "小白";dog.age = 3;dog.shout();System.out.println(dog.name);System.out.println(dog.age);}}
/*** package com.xin.oop.Demo3;public class Pet {public String name;public int age;public void shout() {System.out.println("叫了一声");}
}*//*** public static void main(String[] args) {* Student student = new Student();* //类实例化后会返回一个自己的对象* //对象就是类的一个具体实例* Student xiaoming = new Student();* xiaoming.name = "小明";* xiaoming.age = 3;* System.out.println(student.name);* System.out.println(xiaoming.name);* System.out.println(xiaoming.age);* }* package com.xin.oop.Demo2;* * //学生类* public class Student {* // 属性：字段* String name;* int age;* * // 方法* public void study() {* System.out.println(this.name + "在学习");* }* }* *//*** package com.xin.oop.Demo2;* * //一个项目应该只存一个main方法* public class Applicaton {* public static void main(String[] args) {* // 实例化一个对象* Person person = new Person();* //调用第一个无参* System.out.println(person.name);* Person person1 = new Person("xixi");* //有了参数就调用第二个有参构造器* System.out.println(person1.name);* }* * }* * package com.xin.oop.Demo2;** public class Person {* String name;** // 即使什么都不写也默认有一个方法* // public Person(){}* // 这个方法没有返回值,和类的名字相同* public Person() {** }** public Person(String name) {* // 前一个name是属性，后一个是局部变量* this.name = name;* }* }**/

使用new关键字创建对象

1. 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始值以及对类中构造器的调用。
2. 类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
   1. 必须和类的名字相同
   2. 必须没有返回类型，也不能写void
3. 构造器：必须要在同一层包下
   1. 实例初始值
   2. 使用new关键字，本质是在调用构造器
   3. 一旦定义有参构造，想调用无参构造必须显示定义，也就是必须手写无参构造器。
   4. 有参和无参同时出现相当方法的重载

创建对象内存分析

小结：

1. 类与对象：类是一个模板，对象是一个具体的实例
2. 方法：定义，调用
3. 对应的引用：引用类型：对象是通过引用来实现的。基本类型（8）
4. 属性：字段Field 成员变量。
   修饰符 属性类型 属性名=属性值 。修饰符（public之类的）
   默认初始化：
   1. 数字：0 /0.0
   2. char:u0000
   3. boolean:false
   4. 引用：null
5. 对象的创建和使用：
   1. 必须使用new关键字创造对象，还要有构造器
   2. 对象的属性 Person xixi = new Person（）；
      属性是：xixi。name
   3. 对象的方法：xixi.sleep()
6. 类：由属性和方法组成
   1. 静态的属性： 属性
   2. 动态的行为： 方法

面向对象的三大特性

封装：属性私有 private set/get

  private String name;private char sex;public String getName() {return this.name;}public void setName(String name) {this.name = name;}public void setSex(char sex) {this.sex = sex;}public char getSex() {return sex;}public static void main(String[] args) {Student s1 = new Student();s1.setName("xin");System.out.println(s1.getName());}

继承：的本质是对某一些类的抽象

1. extends的意思是扩展，子类是父类的扩展
2. java类中只有单继承，没有多继承！：一个儿子只有一个爸爸，一个爸爸可以有多个儿子。
   1. 继承是类和类之间的一种关系。
   2. 继承关系的两个类，一个为字类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
   3. 子类和父类之间，从意义上来讲应该具有”is a“的关系。
   4. 子类会继承父类所有的方法。（修饰符pubilc）
3. object类：在java中所有的类，都直接或间接继承object类
4. super

注意：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法

vs this

1. 代表对象不同：
   1. this：本身调用者这个对象
   2. super：代表父类对象的应用
2. 前提：
   1. this：没有继承也可以使用
   2. super：只能在继承条件才可以i使用
3. 构造方法：
   1. this（）：本类的构造
   2. super（）:父类的构造

点击查看代码

package com.xin.oop.Demo2;//学生类
public class Student extends Person {private String name = "xi";public Student() {// 隐藏代码super（）;继承了父类的构造器，必须放在子类构造器的第一行System.out.println("student无参执行");}public void test(String name) {System.out.println(name);// 这个是传的参数System.out.println(this.name);// 这个是private定义了的属性System.out.println(super.name);// 用super调用父类属性}public void print() {System.out.println("student");}public void test1(String name) {print();this.print();super.print();}}
package com.xin.oop.Demo2;public class Person {public Person() {System.out.println("person无参执行");}protected String name = "xin";public void print() {System.out.println("person");}
}* public static void main(String[] args) {* // 实例化对象可以调用* Student student = new Student();* // student.test("xixi");* // 这个就是传的参数* student.test1(null);* }

私有的东西无法被继承，一般可以写protected
隐藏代码super（）;继承了父类的构造器，必须放在子类构造器的第一行
当父类的写了有参构造，就不能再写无参构造了，父类不能写无参，子类也就不能调用父类无参，只能调用有参，
5. 方法重写
重写是方法的，和属性无关
静态方法属于类本身，正确的调用方式是通过类名直接调用而不是实例化

点击查看代码

package com.xin.oop;import com.xin.oop.Demo4.A;
import com.xin.oop.Demo4.B;//import com.xin.oop.Demo2.Student;public class App {public static void main(String[] args) {A a = new A();a.test();// 父类的引用指向子类B b = new A();b.test();}
}
package com.xin.oop.Demo4;public class A extends B {public void test() {// super.test();System.out.println("A>=test()");}}
package com.xin.oop.Demo4;public class B {public void test() {System.out.println("B>=test()");}}

重写：子类的方法必须和父类一致，方法体不同。

1. 非静态才可以重写，属性只有是public才可以，static类不可以进行方法重写。用static直接调用A.test(),B.test()，会分辨输出各自类的方法里的输出，因为A是继承B的
2. 重写是子类的访问权限不能比父类严格，所有不可以是private，修饰范围可以扩大。public>protected>default>private
3. 需要有继承关系，子类重写父类的方法
4. 参数列表必须相同
5. 抛出的异常：范围可以被缩小，但不能扩大。

多态：同一个方法可以根据发生对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向的对象的引用的类型有很多。
多态存在的条件：

1. 有继承关系
2. 子类重写父类方法，不可重写的：
   1. static方法属于类，不属于实例
   2. final常量
   3. private私有属性
3. 父类引用指向子类对象 father f1= new son();

注意事项：

1. 注意：多态是方法的多态，属性没有多态性
2. 父类和子类，有联系，类型转换异常！ClassCastException

instanceof 类型转换

父子关系之间联系才有true

点击查看代码

ackage com.xin.oop;import com.xin.oop.Demo2.Person;
import com.xin.oop.Demo2.Student;public class App1 {public static void main(String[] args) {// 父类的引用指向子类Person student = new Student();//student能调用的方法都是自己的或者继承父类的。//person 不能调用子类独有的方法Student s1 = new Student();s1.run();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大student.run();//子类重写了父类的方法就执行子类的方法Object object = new Object();System.out.println(object instanceof Student);//trueSystem.out.println(object instanceof Person);System.out.println(object instanceof Object);System.out.println(object instanceof String);//false}
}

Person obj = =new Student（）；
高转低:会丢失一些方法
Student student= （Student) obj;
((Student)obj).go();

static关键字

点击查看代码

package com.xin.oop.Demo5;
//静态导入包
import static java.lang.Math.random;
public class Person {{//可以赋初始值System.out.println("匿名代码块");}// static只执行一次并且在第一次的时候先执行，其他的都每次都可以执行static {System.out.println("静态代码块");}public Person() {System.out.println("构造方法");}public static void main(String[] args) {Person person1 = new Person();Person person2 = new Person();System.out.println(random());}
}

抽象类和接口

抽象类

1. abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类。
2. 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
3. 抽象类，不能使用neew关键字来创建对象，它是用来让子类继承的。
4. 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
5. 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

接口

1. 普通类：只有具体实现
2. 抽象类：具体实现和规范（抽象方法）都有
3. 接口：只有规范
   1. 接口就是规范，定义的是一组规则，体现了显示世界中“如果你是。。。，则必须能。。。”的思想
   2. 接口本质是契约，就像我们人间的法律一样，制定好后大家都遵守
   3. oo的精髓，事对对象的抽象，最能体现这一点的就是接口。
   4. 声明类的关键字是class，声明接口的关键字是interface。
4. 接口里的东西都是抽象的 publicabstract
   可以直接void run（）；
5. 接口都需要实现类 用:implements 接口
6. 实现接口中的类就必须重写接口里的方法
7. 利用接口实现多继承,接口不能被实例化，接口中没有构造方法
8. 常量:public static final

内部类及OOP实战

内部类就是在一个类中再定义一个类
通过外部类来实例化内部类
outer.inner inner = outer.new inner();
inner.in//调用内部类方法
可以获得外部类的私有属性