java：面向对象全代码理解版

java面向对象

1.类和对象的创建

类是一种抽象的数据类型，它是对某一事物的整体定义，对象是一个类的具体的实例。

如人是一个类，而男人女人是他的一个实例对象。

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class SubjectCreate {

    //属性
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"正在学习！");
    }
}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象

        SubjectCreate create = new SubjectCreate();
        SubjectCreate create1 = new SubjectCreate();
        create.name="xiaoming";
        create.age=12;
        create1.name="xiaohong";
        create1.age=18;
        System.out.println(create.name);
        System.out.println(create.age);
        create.study();
        System.out.println(create1.name);
        System.out.println(create1.age);
        create1.study();
    }
}

构造器：每个类都有一个默认的构造器，没有返回值，方法名字和类名一样，在使用new关键字的时候必须有一个构造器，才能为该对象注入值。

重载构造器：可以自己定义一个有参构造器，通过该有参构造器在new的时候为对象传值，重写了有参之后就要自己定义无参构造了，否则就不能使用了。

//重载构造器
public SubjectCreate(String name,int age){
    this.name=name;
    this.age=age;
}

//有参构造器赋值
SubjectCreate create = new SubjectCreate("xiaoming",18);
SubjectCreate create1 = new SubjectCreate("xioahong",89);
create.study();
create1.study();

2.面向对象三大特性

封装：将类中的数据封装起来，只暴露一个接口给对象调用。即将属性私有化，提供set/get方法即可。

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:59
 */
public class Enclosure {
    //私有属性
    private String name;
    private int age;
    //set方法
    public void setName(String name){
        this.name=name;
    }

    public void setAge(Integer age){
        this.age=age;
    }

    //get方法
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象
        //对私有化属性调用公共方法设置和获取
        Enclosure enclosure = new Enclosure();
        enclosure.setName("tata");
        enclosure.setAge(12);
        System.out.println(enclosure.getName());
        System.out.println(enclosure.getAge());
    }
}

封装可以提高代码的安全性，保护数据。

统一接口

方便调用

继承：一个类通过extends关键字可以继承另一个类，子类就可以拥有父类的所有的属性和方法。

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-21:11
 */
 //没有任何属性和方法的儿子定义了继承父类
public class ExtendsSon extends ExtendsFather {

}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-21:11
 */
//有属性和方法的父类
public class ExtendsFather {

    String name;
    String sex;

    public void study(){
        System.out.println("father正在学习");
    }
}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象
       //实例化一个子类，打印出父类的方法
        ExtendsSon son = new ExtendsSon();
        son.study();
    }
}

super关键字与子类重写父类方法

super :为了区别当子类和父类有同名的属性或者方法时，区别到底子类调用的是自己还是父类。super.指向父类的方法或者属性。

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

super必须只能出现在子类的方法中

super和this不能同时调用构造方法

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象
       //实例化一个子类，打印出父类的方法
        ExtendsSon son = new ExtendsSon();
        System.out.println(son.name);
        son.study();
    }
}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-21:11
 */

public class ExtendsSon extends ExtendsFather {
   String name="son";
    
//使用super关键字调用了父类中的方法
   public void study(){
       super.study();
    }
}

子类重写父类方法

非静态方法。

public修饰的

重写的方法是子类继承了父类的方法，对父类的方法进行重写。参数和方法名必须相同。

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-14-7:49
 */
public class Son extends Father{
    //子类重写父类的test方法
    public  void test(){
        System.out.println("son==>test");
    }
}

package com.javase.Subject;

import com.sun.org.apache.xml.internal.res.XMLErrorResources_tr;

/**
 * @author panglili
 * @create 2022-07-14-7:49
 */
public class Father {
    //父类被子类重写的方法
    public  void test(){
        System.out.println("father==>test");
    }
}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象
       //父类的引用指向子类
        Father father = new Son();
        Son son=new Son();
        son.test();
        father.test();
        //输出
//        son==>test
//        son==>test

    }
}

多态：父类的引用指向子类对象

多态必须是具有继承关系的

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

方法需要重写，父类就会调用到子类的重写方法

父类要调用子类中有的而自己没有的方法，就会强转为子类。

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象
       //父类的引用指向子类
        Father father = new Son();
        Son son=new Son();
        son.test();
        father.test();
        //强制类型转换
        ((Son) father).eat();
        //输出
//        son==>test
//        son==>test

    }
}

instanceof关键字：

因为父类转换为子类的时候是向下转型去调用子类方法，是具有父子关系的两个类之间，instanceof关键字就是判断这种父子关系的关键字。

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象
       //父类的引用指向子类
        //System.out.println(x instanceof y);
        //x和y有父子关系转换才能通过
        Father father = new Son();
        Father instance = new Instance();
        
        System.out.println(father instanceof Object);//true
        System.out.println(father instanceof Father);//true
        System.out.println(father instanceof Instance);//false
        System.out.println(instance instanceof Father);//true
        System.out.println(instance instanceof Son);//false



    }
}

5.static

静态的，跟类一起加载。

静态变量：可以直接用类名访问。

静态方法：只能调用静态的属性和方法，因为它先加载在内存中。

静态代码块：会先加载一些初始化作用的数据。

6.抽象类和接口

被abstract修饰的类就叫抽象类。不能被new出来，只能被子类继承。

被abstract修饰的方法就是抽象方法，抽象方法只有方法定义，没有实现，只能由继承它的子类实现，除非继承它的子类也是抽象的。

（1）抽象

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-14-8:50
 */
public abstract class AbstractUse {
    //抽象类中的抽象方法，没有实现，只有定义
    public abstract void test();

    //抽象类中的普通方法，可以有实现
    public void test1(){
        System.out.println("普通方法");
    }
    }

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-14-8:53
 */
public class AbstractSon extends AbstractUse {

    //实现了抽象父类，就必须重写抽象方法
    @Override
    public void test() {
        System.out.println("子类重写的抽象方法");
    }
}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象

        //不能new抽象类，只能被继承
      //  AbstractUse use = new AbstractUse();

        AbstractSon son = new AbstractSon();
        //子类调用父类的普通方法和抽象方法
        son.test();
        son.test1();

    }
}

（2）接口

使用interface定义替换class类，就定义为一个接口。

接口里面只有抽象方法。

package com.javase.Subject;
/**
 * @author panglili
 * @create 2022-07-14-9:04
 */
public interface Interface {
     void add();
     void sub();
     int mul();
}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-14-9:05
 */
public class InterfaceImpl implements Interface {
    @Override
    public void add() {
        System.out.println("实现接口的方法add");
    }

    @Override
    public void sub() {
        System.out.println("实现接口的方法sub");
    }

    @Override
    public int mul() {
        System.out.println("实现接口的方法mul");
        return 0;
    }
}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象

     //接口实现类实例化一个对象
        InterfaceImpl anInterface = new InterfaceImpl();
          anInterface.add();
          anInterface.mul();
          anInterface.sub();

    }
}

7.内部类

在类的内部在创建的类，可以直接获取类的私有属性。

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-14-9:11
 */
public class InterClassUse {
    private static int age=10;
    public static void test(){
        System.out.println("这是一个外部类");
    }



    public class inter{
        public void test1(){
            System.out.println("这是一个内部类"+"外部类的值为"+age);
        }
    }


}

package com.javase.Subject;

/**
 * @author panglili
 * @create 2022-07-13-20:26
 */
public class Application {
    public static void main(String[] args) {

        //主启动类
        //在此实例化一个类对象

        //实例化一个内部类，必须先实例化它的外部类，由外部类实例化内部

        InterClassUse interClassUse = new InterClassUse();
        InterClassUse.inter inter = interClassUse.new inter();

        //内部类可以直接获取外部类的私有属性
        inter.test1();

    }
}