JavaSe基础2022年12月08日学习内容

JavaSe-2022-12-08面向对象

每日一句:闻鸡起舞，成就拼搏劲旅师；天道酬勤，再现辉煌王者风。

学习内容:封装、static静态修饰符、重写（覆盖）、向上造型

• 封装

  • Java的封装，就相当于把汽车的零件组装起来变成了一辆车，你不知道他的具体结构但是你可以使用它；

  • 我们在程序设计的过程中要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己来完成，不允许外部干涉，低耦合：就是， 仅暴露少量的方法给外部使用

  • //get/set方法 封装一个类
    public class Person {
        String name;
        private int age; //1.使用private私有属性
        //2.提供公开的访问方法get/set
        public String getName() { //获取属性值的方法
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {  //设置属性值
            //加入逻辑判断
            if(age < 0 || age > 150){
                System.out.println("年龄不合理");
                return; //终止方法的运行
            }
            this.age = age;
        }
    
        public Person() {
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    
    //测试类
    public class PersonTest {
        public static void main(String[] args) {
            Person p = new Person();
    //        p.age = 100000; //不合理
            p.setAge(100);
            System.out.println(p.getAge());
        }
    }
    

• static静态修饰符

  • 修饰成员变量，使之成为静态变量,访问静态变量建议使用类名.访问

  • 修饰成员方法，称为静态方法

  • 修饰代码块，静态代码块

  • 修饰类，静态内部类

    • public class StaticTest {
          public static void main(String[] args) {
              Too t1 = new Too();
              Too t2 = new Too();
              t1.a++;
              Too.b++;
              t2.a++;
              Too.b++;
              System.out.println(t1.a);//1
              System.out.println(t1.b);//2
              System.out.println(t2.a);//1
              System.out.println(t2.b);//2
          }
      }
      
      class Too extends Father{
          int a; //成员变量 每个对象自己独一份
          static int b; //静态变量 所有对象共用一份
          //当存在父子类,且含有构造方法,普通代码块,静态代码块,执行的顺序如下
          //  父类静态代码块->子类静态代码块->父类代码块->父类构造方法
          //  ->子类代码类 ->子类构造方法
          Too(){
              super();
              System.out.println("我是构造方法");//7
          }
          //每创建一个对象前执行一次所有代码块
          {
              System.out.println("我是代码块1");//4
          }
          {
              System.out.println("我是代码块2");//5
          }
      //    静态代码块在类加载的时候就执行且只能执行一次
         static {
             System.out.println("我是静态代码块");//2
         }
      
          //成员方法f1 在成员方法内部直接调用本类的其他成员方法和静态
          public void f1(){
              f2();//成员方法
              f3();//静态方法
          }
          //成员方法f2
          public void f2(){
          }
          //静态方法f3 首先执行了静态方法再执行成员方法 ，在调用成员方法的时候 还没有创建出来 所以不能调用
          public static void f3(){
              f4();//静态方法中可以直接调用静态方法
      //        f2(); //但是不能够在静态方法中调用成员方法
          }
          //静态方法f4
          public static void f4(){
          }
      }
      
      class Father{
          Father(){
              System.out.println("父类构造方法");
          }//6
          {
              System.out.println("父类代码块");//3
          }
          static {
              System.out.println("父类静态代码块"); //1
          }
      }
      

  • 使用静态方法修饰的属性存放在静态区

    • 

• 重写（覆盖）

  • 父类中那些方法不能被覆盖(重写)

    • 私有方法
    • 构造方法
    • 静态方法
    • 被final修饰的方法，final最终的，不能被修改

  • public class FunctionTestRiding {
        public static void main(String[] args) {
    //        在Boo类中调用f私有方法 看能否被调用
            Aoo b = new Boo();
    //        b.f(); //无法被调用
            b.f1();
            b.f3();
        }
    }
    class Aoo{
        public void f3(){
            System.out.println("Aoo f3 可以被重写");
        }
    //    私有方法
        private void f(){
            System.out.println("Aoo 私有方法");
        }
        public static void f1(){
            System.out.println("Aoo f1静态方法");
        }
    //    被final修饰
        public final void f2(){
            System.out.println("Aoo f2被final修饰的");
        }
    }
    class Boo extends Aoo{
        public void f3(){
            System.out.println("Boo f3 可以被重写");
        }
    //    private void f(){
    //        System.out.println("Boo 私有方法");
    //    }
    //    感觉被重写了 其实静态方法放在了静态代码区
        //子类自定义的静态方法 并不是重写
        public static void f1(){
            System.out.println("Boo f1静态方法");
        }
    }
    

• 向上造型

  • 本质上是代码的复用,减少代码量

  • 父类的引用指向子类的对象

  • public class TestFlyingObject {
        public static void main(String[] args) {
          //主要是看new BigPlane去调用方法
            TestFlyingObject t1 = new BigPlane();
            TestFlyingObject t2 = new AirPlane();
            move(t1);
            move(t2);
        }
        public void move(){
    
        }
        public static void move(TestFlyingObject t){
            t.move();
        }
    }
    class BigPlane extends TestFlyingObject{
        public void move(){
            System.out.println("大敌机在移动...");
        }
    }
    class AirPlane  extends TestFlyingObject{
        public void move(){
            System.out.println("小敌机在移动...");
        }
    }
    

• gitee代码仓库地址:https://gitee.com/Zhengsenbing/java-se-basic