JavaSE自学笔记Real_004

JavaSE自学笔记Real_004

封装

Private get set

public class Fengzhuang {
    public static void main(String[] args) {
        //========================================
        //封装
        //========================================
        /*
        1、提高了程序的安全性，保护数据
        2、隐藏代码的实现细节
        3、统一接口
        4、系统的可维护性提高
         */

        Student s1 = new Student();
        s1.setName("张三");
        System.out.println(s1.getName());
    }
}

//类 private:私有
public class Student {
    //属性表示
    private String name; //名字
    private int id; //学号
    private char sex; //性别

    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法

    //get 获取这个数据
    public String setName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
}

继承

 //=======================================
        //继承
        //=======================================
        /*
        继承的本质时对某一批类的抽象，从而事项显示世界更好的建模
        extends的意思是扩展，子类是父类的扩展
        Java中类只有单继承，没有多继承

        继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等
        继承关系的两个类，一个为子类（派生类），另一个为父类（基类）。子类继承父类，使用关键字extends来表示
        子类和父类之间从意义上讲应该具有“is a”的关系
         */

        //属性的修饰词：
        //public  protected  default  private
        //在java种所欲的类都默认直接或间接继承Object这个类

- super关键字与this关键字

/*
super注意点：
    1、super调用父类的构造方法，必须在构造方法的第一个
    2、super必须只能出现在子类的方法或者构造器中
    3、super和this不能同时调用构造方法
比较
this：
    代表的对象不同：
        this：本省调用者这个对象
        super：代表父类对象的应用
    前提：
        this：没有继承也可以使用
        super：只能在继承条件下才可以使用
    构造方法：
        this()：本类的构造
        super()：父类的构造
 */

public class Application {
    public static void main(String[] args) {
        Students students = new Students();
        students.test("王五");
        students.test1();
    }
}




//==================================================================
//在Java中，所有的类，都默认直接或简介继承Object
//HumanBeing 人：父类
public class HumanBeing {
    //无参构造器
    public HumanBeing(){
        System.out.println("HumanBeing无参构造执行了");
    }

    protected String name = "张三";

    //private私有关键字修饰的属性或方法无法被子类调用

    public void print(){
        System.out.println("Person");
    }
}





//================================================================
//学生 is 人：派生类  子类
//子类继承了父类，就会拥有父类的全部方法
public class Students extends HumanBeing{
    //无参构造器
    //默认先执行父类的无参构造器，再执行子类的无参构造器
    public Students(){
        System.out.println("Students无参构造执行了");
    }

    private String name = "李四";

    public void print(){
        System.out.println("Student");
    }

    //使用Super关键字可以调用父类的静态属性
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name); //输出自己的name即李四
        System.out.println(super.name); //输出父类的name即张三
    }

    //使用super还可以调用父类的动态方法
    public void test1(){
        print();
        this.print();
        super.print();
    }
}

- 重写

/*
重写：需要有继承关系，子类重写父类的方法
    1、方法名必须相同
    2、参数列表必须相同
    3、修饰符：范围可以扩大，但是不能缩小：public>protected>default>private
    4、抛出的异常：范围可以缩小，但是不能扩大：ClassNotFundException --> Exception(大)

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

为什么要重写：
    1、父类的功能，子类不一定需要，或者不一定满足
    2、Alt+Insert：override
 */


public class Application1 {
    public static void main(String[] args) {
        //方法的嗲用只和左边还有定义的数据类型有关
        A a = new A();
        a.test();  //A
        //父类的引用指向子类（里氏转换）
        B b = new A();
        b.test();  //B

        //非静态方法
        a.test1();
        b.test1();

    }
}



//================================================================
public class A extends B{
    //静态方法
    public static void test(){
        System.out.println("A=>test()");
    }

    //非静态方法
    public void test1(){
        System.out.println("A=>test1()");
    }


}


//===============================================================
public class B {
    //静态方法
    public static void test(){
        System.out.println("B=>test()");
    }

    //非静态方法
    public void test1(){
        System.out.println("B=>test1()");
    }
}

多态

import com.NUST.Demo004.Person;
import com.NUST.Demo004.Student;

/*
多态：
    即同一个方法可以根据发送对象的不同二采用多种不同的行为方式
    一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多

多态注意事项：
    1、多态是方法堵塞多态，属性没有多态
    2、两个类之间需要有继承关系才能进行类型转换，富则会报错：ClassCastException
    3、多态存在的条件：有继承关系，方法需要重写，父类引用指向子类对象，Father f1 = new Son();
    4、以下修饰词的方法不能被重写：
        （1）static方法：属于类本身，不属于实例
        （2）final 常量
        （3）private 方法属于父类实例私有
 */

public class Application2 {
    public static void main(String[] args) {
        //多态
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //父类的引用指向子类，若子类没有重写父类的方法，则执行父类的方法
        //若子类重写了父类的方法，则执行子类的方法

        //可以指向的引用类型就不确定的：父类的引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        //子类会重写父类的方法，执行子类的方法
        s2.run(); //son
        s1.run(); //son
    }
}


//==============================================================
public class Person {
    public void run(){
        System.out.println("run");
    }
}

//=============================================================
public class Student extends Person{
    public void run(){
        System.out.println("son");
    }
}

- instanceof关键字与类型转换

import com.NUST.Demo004.Person;
import com.NUST.Demo004.Student;
import com.NUST.Demo004.Teacher;

import java.util.Scanner;

public class Application2 {
    public static void main(String[] args) {
        //=========================================================
        //instanceof关键字
        //=========================================================
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person); //true
        System.out.println(object instanceof Object); //true
        System.out.println(object instanceof Teacher); //False
        System.out.println(object instanceof String); //False

        System.out.println("==============================================");

        Person person = new Student();
        System.out.println(person instanceof Object); //true
        System.out.println(person instanceof Person); //true
        System.out.println(person instanceof Object); //true
        System.out.println(person instanceof Teacher); //False
        //System.out.println(person instanceof String);  //

        //===============================================================
        //类型之间的转换
        //===============================================================
        /*
        1、父类引用指向子类的对象
        2、把子类转换为父类，向上转换：直接就能转换  可能会丢失子类的一些方法
        3、把父类转换为子类，向下转换：必须进行强制转换
        4、方便方法的调用，减少重复的代码
         */
        //   高    ->       低
        Person obj = new Student();

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        Student student = (Student) obj; // 简写：((Student)obj).go();
        student.go();
    }
}

//=====================================================================
public class Person {
    public void run(){
        System.out.println("run");
    }
}

//====================================================================
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }

}


//===================================================================
public class Teacher extends Person{
}

抽象类（abstract）

//abstract 关键字表示抽象类 extends只能单继承， （但是接口可以多继承）
public abstract class Action {
    //如果有一个方法是不必要的但是必须要写的，太麻烦，可以让别的类帮忙把这些都写了
    //abstract 抽象方法  只有方法的名字即可。没有方法的实现
    public abstract void doSomething();

    //1、抽象类不能进行实例化，也就是不能用new关键字，只能用子类来实现它
    //2、抽象类里面可以写普通的方法
    //3、一个类里面由抽象方法，那么这个类就必须设置为抽象类
}

接口

/*
接口的作用：
    1、它是一种约束
    2、定义了一些方法，让不同的类进行实现
    3、接口的方法的修饰符都是：public abstract
    4、接口里面的变量的修饰符都是：public static final
    5、接口不能被实例化
    6、implement可以实现多个结成，相当于多继承
    7、必须要重写接口中的方法
 */


//抽象类 extends只能单继承
//类 可以实现接口 implement 接口
//实现接口的类必须要重写接口中的方法
//接口从另一种角度实现了多继承
public class UserServiceImpl implements UserService, TimeService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timerScan() {

    }
}

//==========================================================
//接口的基础学习==============================
//interface 定义接口的关键字
public interface UserService {
    //接口中的所有定义其实都是抽象的  public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}


//======================================================
public interface TimeService {
    void timerScan();
}

内部类

public class Application4 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
}

//==================================================
public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类的额方法");
        }
    }
}