Day12

合集 - java(14)

1.第一天2023-03-292.第二天2023-04-013.Demo052023-04-044.Demo04 二进制 左右移 三元运算符2023-04-035.Demo03 数据类型 类型转换 内存溢出2023-04-026.输出Hello World2023-04-017.Day132023-04-24

8.Day122023-04-19

9.Day112023-04-1810.Day102023-04-1211.Day092023-04-1112.Day082023-04-1013.Demo072023-04-0614.Demo062023-04-05

收起

 package com.oop.demo02;
 ​
 import com.oop.demo03.Pet;
 ​
 //一个项目应该只存在应该mian方法
 public class Application {
     public static void main(String[] args) {
         /*
         1.类与对象
             类是一个模板：抽象，对象是一个具体的实例
         2.方法
             定义、调用
         3.对应的引用
             引用类型： 基本类型（8）
             对象是通过引用来操作的：栈-->堆
         4.属性：字段Field  成员变量
             默认初始化：
                 数字： 0  0.0
                 char： u0000
                 boolean： false
                 引用： null
 ​
              修饰符  属性类型 属性名 = 属性值！
          5.对象的创建和使用
             - 必须使用new 关键字创造对象， 构造器 Person kuangshen = new Person（）；
             -对象的属性 kuangshen.name
             -对象的方法 kuangshen.sleep（）
          6.类：
             静态的属性  属性
             动态的行为  方法
             
          封装、继承、多态
          */
     }
 }

 package com.oop.demo04;
 ​
 //类
 public class Student {
 ​
     //名字 private私有的
     private String name;
     //学号
     private int id;
     //姓别
     private char sex;
     private int age;
 ​
     //提供一些可以操作这个属性的方法！
     //提供一些public 的get、set方法
 ​
     //get 获得这个数据
     public String getName(){
         return this.name;
     }
 ​
     //set 给这个数据设置值
     public void setName(String name){
         this.name = name;
     }
 ​
     //alt + insert
 ​
     public int getId() {
         return id;
     }
 ​
     public void setId(int id) {
         this.id = id;
     }
 ​
     public char getSex() {
         return sex;
     }
 ​
     public void setSex(char sex) {
         this.sex = sex;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         if (age>120 || age<0){//不合法
             this.age = 3;
         }else {
             this.age = age;
         }
 ​
     }
     //学习（）
 ​
     //睡觉（）
 }
 ​
 /*    public static void main(String[] args) {
 ​
         *//*
             1.提供程序的安全性，保护数据
             2.隐藏代码的实现细节
             3.统一接口
             4.系统可维护增加了
          *//*
 ​
         Student s1 = new Student();
 ​
         s1.setName("钟意");
         //方法名，参数列表
         System.out.println(s1.getName());
 ​
         s1.setAge(99);
         System.out.println(s1.getAge());
     }*/

父亲

 package com.oop.demo05;
 ​
 import java.util.zip.Deflater;
 ​
 //在java中 所有的类，都默认直接或者间接继承Object
 //Person 人 :父亲
 public class Person {//extends Object
 ​
     //public
     //protected
     //default
     //private
 ​
 ​
     public Person() {
         System.out.println("Person无参执行了");
     }
 ​
     private int money = 10_0000_0000;
 ​
     protected String name = "zhangsan";
 ​
     public void say(){
         System.out.println("说了一句话");
     }
 ​
     public void print(){
         System.out.println("Person");
     }
 ​
     public int getMoney() {
         return money;
     }
 ​
     public void setMoney(int money) {
         this.money = money;
     }
 }

子类

 package com.oop.demo05;
 ​
 //学生 is 人 : 派生类：子类
 public class Student extends Person{
 ​
     public Student( ) {
         //隐藏代码：调用了父类的无参构造
 ​
         super();//调用父类的构造器，必须放在子类构造器的第一行
         System.out.println("Student无参执行了");
     }
 ​
     private String name = "lisi";
 ​
     public void print(){
         System.out.println("Student");
     }
 ​
     public void test1(){
         print();//Student
         this.print();//Student
         super.print();//Person
     }
 ​
     public void test(String name){
         System.out.println(name);
         System.out.println(this.name);
         System.out.println(super.name);
 ​
     }
 ​
 ​
 }

 package com.oop.demo02;
 ​
 import com.oop.demo05.Person;
 import com.oop.demo05.Student;
 ​
 //一个项目应该只存在应该mian方法
 public class Application {
     public static void main(String[] args) {
 ​
         Student student = new Student();
         //student.test("张三");
         //student.test1();
     }
 }

//静态的方法和非静态的方法区别很大！
    //静态方法： //方法的调用只和左边，定义的数据类有关

//非静态：重写

 super注意点：
     1.super调用父亲的构造方法，必须在构造方法的第一个
     2.super 必须只能出现在子类的方法或者构造方法中！
     3.super 和 this 不能同时调用构造方法！
 ​
 ​
 Vs this：
     代表的对象不同
         this： 本身调用者这个对象
         super：代表父亲对象的应用
     前提
         this：没有继承也可以使用
         super：只有在继承条件才可以使用
     构造方法
         this() ;本类的构造器
         super() ;父类的构造器！
 ​
 ​
 重写：需要有继承关系，子类重写父类！
     1.方法名必须相同
     2.参数列表必须相同
     3.修饰符：范围可以扩大： public>Protected>Default>private
     4.抛出的异常：范围可以被缩小，但不能扩大； ClassNotFoundException --> Exception(大)
 ​
 重写，子类的方法和父类必须要一致；方法体不同！
 ​
 为什么需要重写
     1.父类的功能，子类不一定需要，或者不一定满足！
     Alt + Insert  ； override;