Java面向对象

面向对象思想：

物以类聚，分类的思维模式，思考问题首先要解决问题需要哪些那些分类，然后对分类进行单独思考，最后，对于某个分类下的细节进行面向过程的思索。

• 对于复杂事物，我们需要从整体上合理分析整个系统，需要面向对象的思路。但是具体到微观操作，仍然需要面向过程的思路去处理。

• 面向对象本质：以类的方式组织代码，以对象的方式封装数据。

• 三大特性：封装、继承、多态

• 类是对象操作的模板，类不能够直接使用，必须通过实例对象来使用。实例化这个类 用new

• 对象类型 对象名 = 对象值；

  面向对象

package oop.OppDemo;
//面向对象：以类的方式组织代码，以对象的形式组织（封装）数据
//OopDemo01类
public class OopDemo01 {
    //main方法
    public static void main(String[] args) {
​
    }
    //     方法
    //    修饰符   返回值类型   方法名（形参）{
    //   方法体
    //   return 返回值；}
​
    //return 结束方法，返回一个结果
    public String bestFriend(){//有返回值
        return "黄好";
    }
    public void bestFriend1(){//无返回值
        return ;
    }
    public int max(int a,int b){//有参数
        return a>b?a:b;
    }
}

实例化类

package oop.OppDemo;
​
import oop.OopDemo07.Student;
​
public class OopDemo02 {
    public static void main(String[] args) {
        /*
        实例化这个类 new
        对象类型  对象名  = 对象值；
        */
        Student student=new Student();
        student.dream();//通过对象名.方法来调用
    }
}
/**
 * 静态 static
 * 静态是和类一起加载的（先出现），而非静态是在类实例化后 才存在
 * main方法中实例化类，调用非静态方法用对象.方法；调用静态方法可用类名（或对象）.方法
 */

值传递

package oop.OppDemo;
//值传递
//用debug很清楚哇，哈哈哈哈
public class OopDemo03 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);//1
        OopDemo03(a);
        System.out.println(a);//1
    }
    public static void OopDemo03(int a){//没有返回值
        a=10;
    }
}

引用传递

package oop.OppDemo;
//引用传递  对象  本质还是值传递
//对象  内存
public class OopDemo04 {
    public static void main(String[] args) {
​
        Person person = new Person();
        System.out.println(person.name);//null
​
        OopDemo04.change(person);
        System.out.println(person.name);//jiji
    }
    //写一个函数尝试去改变内容
    public  static void change(Person person){
        //person是一个对象指向的Person person = new Person();，是一个具体的人，可以改变
        person.name="jiji";//引用传递
        //String name="jiji";//null  将构造器 与引用传递区分
    }
​
​
    //定义一个类Person  里面有一个属性 name；
        public static  class Person{
        String name;//null
    }
}

小结

• 使用new关键字创建对象

• 使用new关键字创建对象的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化， 以及对类中构造器的调用

• 类中的构造器是在创建对象的时候必须要调用的

• 构造器特点： 1.必须和类的名字相同 2.必须没有返回类型，也不能写void

  1、类与对象 类是一个模板：抽象；对象是一个具体的实例    2、方法 定义，调用   3、对象的引用 引用类型：八大基本类型 对象是通过引用来操作的：由栈--->堆     4.属性：字段Field成员变量 默认初始化： 数字：0 char：u0000 boolean:false   引用：null

• 修饰符 属性类型 属性名 =属性值；

  5、对象的创建与使用 必须使用new关键字创建对象，构造器 对象的属性： 对象的方法 6、类： 静态的属性：属性 动态的行为：方法 封装 继承 多态

封装性

• 封装 程序设计追求 高内聚 低耦合

• 高内聚就是类的内部数据的操作细节自己完成，不允许外部干涉；低耦合就是仅仅暴露少量的方法给外部使用

• 封装 数据隐藏 通常应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问

• 属性私有 ，getter setter 方法

• 代码实现放在Application 以及 Student类中

  Application类

package oop.OopDemo07;
import oop.OopDemo07.Person;
import oop.OopDemo07.Student;
import oop.OopDemo07.StudentOne;
public class Application {
    //一个项目中应该只有一个main方法
    public static void main(String[] args) {
        //类：抽象的，要实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
​
        Student King = new Student();
        Student huanghao = new Student();
        System.out.println(huanghao.name);//黄好
​
        Person person = new Person("huanghao");//实参传过去，将huanghao传给name，this.name="黄好"
        System.out.println(person.name);//黄好
        System.out.println("========================");
​
        StudentOne studentOne = new StudentOne();
        studentOne.setName("huanghao");
        System.out.println(studentOne.getName());
​
        studentOne.setAge(500);//不合法
        System.out.println(studentOne.getAge());
    }
}

​
学生类

public class Student {
    //属性：字段
    String name;//null
    int age;
​
    //方法(非静态)
    public  void dream(){
        System.out.println(this.name+"强者，不会去在意弱者的想法。");
    }
​
    //构造器
    //实例化初始值
    ///使用new关键字，本质是在调用构造器
    public Student(){
        this.name="黄好";
    }
}

public class Person {
    //一个类即使什么都不写，它也会存在一个方法（隐含的构造器）
    //显示的定义 构造器
​
    String name;
    int age;
    //实例化初始值
    ///使用new关键字，本质是在调用构造器
    public Person(){
    }
​
    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name="huanghao";
    }
​
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
}

package oop.OopDemo07;
//封装
//1.提高程序的安全性，保护数据
//2、隐藏代码的实现细节
//3、统一接口
//4.系统可维护增加了
//关键  私有 private
public class StudentOne {
​
    //内部数据 属性私有
    private String name;
    private int age;
    private char sex;
    //外部接口方法 提供一些可以操作这个属性的方法
    // 提供一些public的get  set 方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
​
    public void setAge(int age) {
        if(age>120||age<0){
            System.out.println("年龄出错");
        }
        else{
            this.age = age;
        }
    }
    public int getAge() {
        return this.age;
    }
}

继承性

• 继承的本质是对某一批类的抽象

• extends 扩展 。子类是父类的继承。

• Java只有单继承，没有多继承。

• 继承是类与类之间的一种关系，除此还有依赖，组合，聚合等

• object类 （查看用CTRL+h）

• super

  1. super调用父类的构造方法，必须在构造方法的第一个

  2. super必须只能出现在子类的方法或构造方法中

  3. super和this不能同时调用构造函数

• super 与 this对比

  1.代表的对象不同：this本身调用这个对象，super代表父类对象的引用

  1. 前提：this没有继承也可以使用；super必须有继承条件才能使用

  2. 构造方法：this（）；本类的构造

     super（）；父类的构造

• 方法重写：需要有继承关系，子类重写父类的方法

  1. 方法名必须相同

  2. 参数列表必须相同

  3. 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private

  4. 抛出的异常：范围可以被缩小但不能被扩大

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

  6. 为啥要重写：父类的功能，子类不一定需要，或者不一定满足！

     alt+insert ：override

package oop.OopDemo08;
//Person 人：父亲
//在Java中，所有的类都默认直接或间接继承Object
//
public class Person {
    public void say() {
        System.out.println("猛兽总是独行");
    }
    int money=10-0000-0000;
    public  int getMoney(){
        return money;
    }
    public void setMoney(int money){
        this.money=money;
    }
    //----------------------
    protected String name="huanghao";
    //----------------------
    public void print(){
        System.out.println("Person");
    }
    //构造器
    public Person(){
        System.out.println("Person无参构造了");
    }
}

package oop.OopDemo08;
//Person 人：父亲
//在Java中，所有的类都默认直接或间接继承Object
//
public class Person {
    public void say() {
        System.out.println("猛兽总是独行");
    }
    int money=10-0000-0000;
    public  int getMoney(){
        return money;
    }
    public void setMoney(int money){
        this.money=money;
    }
    //----------------------
    protected String name="huanghao";
    //----------------------
    public void print(){
        System.out.println("Person");
    }
    //构造器
    public Person(){
        System.out.println("Person无参构造了");
    }
}

package oop.OopDemo08;

//学生 is 人 ：派生类 子类
//子类继承了父亲，就会拥有父亲的全部方法！
//私有的东西无法被继承
public class Student extends Person {

    //--------------------------
    private String name="King";
    public void test(String name){
        System.out.println(name);//吉吉国王
        System.out.println(this.name);//King
        System.out.println(super.name);//huanghao
    }
    //---------------
    public void print(){
        System.out.println("Student");
    }
    public void test(){
        print();
        this.print();
        super.print();
    }
    //构造方法  构造器
    public Student(){
        //隐含代码 ，调用了父类的无参构造
        super();//必须要在子类的第一行

        System.out.println("Student无参构造了");
    }

}
//CTRL +H 可以看到继承关系 java中继承Object类

小结

1、Student能调用的方法是自己的或者继承父类的；
2、Person 父亲型，可以指向子类，但不能调用子类独有的方法；

方法重写

package oop.OopDemo08;
//重写
public class A extends B {
    //@Override//注解  重写
    public static void test() {
        //super.test();
        System.out.println("A->TEST");
    }
}
/**
 * 静态与非静态
 * 静态方法：方法的调用只和左边有关，与右边关系不大
 * 非静态方法：方法重写
 */
package oop.OopDemo08;
//重写是方法的重写，与属性无关
public class B {
    public static void test(){
        System.out.println("B->TEST");
    }
}

多态性

• 同一方法可以根据发送对象的不同而采取多种不同的行为方式。

• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

• 多态存在的条件：有继承关系；子类重写父类方法；父类引用指向子类对象 Father f= new Son();

• 多态是方法的多态，属性没有多态 instanceof

• static 方法 。属于类 ，不属于实例

• final 常量

• private 方法

• 类型转换：父    子

  子类转换为父类，可能丢失一些自己本来的方法

  1、父类的引用指向子类的对象

  2、父类转换为子类，向下转型：强制转换

       方便方法的调用

  3、一个对象的实际类型是确定的 new Student(); new Person();     可以指向的引用类型不确定了：父类的引用指向子类 ；

• 对象能执行那些方法，主要看对象左边的类型，与new右边的关系不大；

代码实例

package oop.OopDemo09;
//多态
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        // new Student();  new Person();
        //可以指向的引用类型就不确定了：父类的引用类型指向子类

        //Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person  父亲型，可以指向子类，但是不能调用子类独有的方法；

        Person s2 = new Student();
        Object s3 = new Student();
        
        s1.run();
        s2.run();//子类重写了父类的方法，执行子类的方法
        //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大
        s1.eat();
        ((Student)s2).eat();//强制类型转换，

        System.out.println("============");
        //instanseof
        //Object >Person>Student
        //instanceof
        //System.out.println(X instanceof Y); 能不能编译通过
        //类与类之间存在父子关系可通过
        Object object = new Student();
        Person person = new Student();
        Student student = new Student();
        System.out.println(object instanceof Object );
        System.out.println(object instanceof Person );
        System.out.println(object instanceof Student );
    }
}

package oop.OopDemo09;

public class Person {
    public void run(){
        System.out.println("hehe");
    }
//多态注意事项
    /**
     * 多态是方法的 多态，属性没有多态
     * 父类和子类，有联系 类型转换异常！  ClassCastException!
     * 存在条件： 继承关系，方法需要重写 ，父类引用指向子类对象，Father f1=new son();
     * static 方法，属于类，不属于实例
     * final，常量
     * private 方法
     */
}

package oop.OopDemo09;

import org.w3c.dom.ls.LSOutput;

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("haha");
    }
    public void eat(){
        System.out.println("婷儿");
    }
    //-------------
    //instanseof

}