JAVA学习Day9【面对对象3】

糖逗

学习视频：https://www.bilibili.com/video/BV17J411G72L?p=20

163-176

/*
*包作用：（1）避免重名（2）分类组织管理众多的类（3）用于访问权限控制
*声明包要求（1）一个源文件.java只能有一句 （2）习惯上用公司的域名倒置+模块名（com商业 org非营利性 gov政府  edu教育）
*如何使用其他包的类
*前提：被使用的类或成员的权限修饰词需要允许跨包使用
*方式：（1）使用全名称：包.类名(2)使用import语句 + 简名（写在package和class之间）
*当语句可以有很多句，导不同包的类
*java.lang包中类可以不使用import语句，直接使用简名称 System String Math...
*如果出现不同包，但是类名相同，只能一个使用简名称一个使用全名称，不能同时使用简名称
*
*/

//文件1
package com.atguigu.pkg //文件名package/com/下的pkg文件

import com.atguigu.bean.Rectangle
//import com.atguigu.bean.*


class test09_01{
        public static void main(String[] args){
                System.out.println("dfd");
                com.atguigu.bean.Circle c1 = new com.atguigu.pkg.Circle();
                c1.printInfo();
                Rectangle r1 = new Rectangle();
        }
}

//文件2
package com.atguigu.bean

public class test09_02{
        public static void main(String[] args){
                private double radius;
                public Circle(){

                }
                public Circle(double r){
                        radius = r
                }
                public void printInfo(){
                        System.out.printIn(r);
                }

        }
}

package com.atguigu.bean

public class Rectangle{
        private double length;
        private double width;

        public Rectangle(){

        }
        public Rectangle(double chang, double kuan){
                length = chang;
                width = kuan;
        }
        public void printInfo(){
                System.out.println(length + " " + width);
        }
}


//统一用utf-8编码

/*
*快捷键ctrl + Y ： 反撤销
*Alt + / ： 内容提示
*ctrl + 1 ： 快速修复
*快速导包：Ctrl + shift + o
*快速复制一行：选中块 ctrl + alt + 上箭头（下箭头）
*快速格式化 ctrl + shift + f
*查看某个类的源代码文件：（1）选中类，按ctrl 单击 （2）ctrl + shift + T 输入类名打开
*多行同时编辑：Alt + Shift + A
*/


/*
*自动生成代码：1.构造器 2.get/set
*Alt + Shift + S 或者选Source菜单
*（1）构造器 Generate Constructor Using Fields...
*（2）get/set Generate Getters And Setters...
*/

/*
*this 当前对象
*（1）构造器：正在创建的对象
*（2）方法：正在调用该方法的对象
*用法：
*（1）this.属性：当局部变量和成员变量同名时，可以在成员变量的前面加this
*（2) this.方法没有非用不可的时候
*（3）this()或this(实参列表)
*this()表示调用本类的无参构造
*this()必须在首行
*this(实参列表)调用有参列表
*/

class test09_04{
        public static void main(String[] args){
                Circle c1 = new Circle(1.2);
                c1.setRadius(2.1);

        }
}

class Circle{
        private double radius;
        public Circle(){
                System.out.println("dfdfd");//用法（3）

        }
        public Circle(double radius){
                this();//用法（3）
                this.radius = radius;//用法（1）
        }
        public void setRadius(double radius){
                this.radius = radius;
        }
        public double getRadius(){
                return radius;//没有同名问题可以不加this
                //return this.radius;
        }
        public double getArea(){
                return 3.14 * radius * radius;
        }
        public void printInfo(){
                System.out.println(radius + " " + getArea());
                //System.out.println(this.radius + " " + this.getArea());//用法（2）
        }        
        
}

class Student{
        private String name;
        private int age;
        private char gender;
        private int score;

        public Student(){

        }
        public Student(String name, int age){
                this.name = name;
                this.age = age;
        }
        public Student(String name, int age, char gender, int score){
                this(name, age);
                //this.name = name;
                //this.age = age;
                this.gender = gender;
                this.score = score;
        }
}


/*
*继承
*(1)延续
*(2)扩展
*为什么要有继承：
*（1）当某个类，需要派生出很多子类别
*如Person需要派生出Teacher、Student等等子类，那么Person中共有的部分就不需要在子类别中再次声明
*（2）当多个类中出现共同的特征时，可以吧共同的部分提取到父类中
*子类：subclass也称派生类
*父类：superclass也称超类或基类
*继承的特点：（1）子类继承了父类
*从事物的特征来说，子类会继承父类的所有特征
*但是从代码操作的角度说，父类中私有的属性、方法在子类中是不能直接使用的
*（2）子类继承父类时，构造器是不能被继承的！！！！！！！！！！！！！！！！！！！！！！！
*（3）子类继承父类时，在子类的构造器中一定要去调用父类的构造器
*默认情况下，调用的父类无参的构造器
*如果父类没有无参构造，则在子类的构造器的首行，必须手动调用父类的有参构造
*（4）JAVA只支持单继承
*（5）JAVA支持多层继承，即父类还有父类
*（6）一个JAVA类可以同时有很多个子类，而且子类还可以有子类
*（7）子类可以扩展父类没有的属性、方法
*/

public class test09_05{
        public static void main(String[] args){
                Teacher t = new Teacher();
                t.setName("dfd");
                t.setAge(18);

                //Teacher t2 = new Teacher("fd", 21);不能直接调用父类的私有构造器，根据继承的特点（2）

        }
        
}

class Person{
        private String name;
        private int age;
        public Person(){

        }
        public Person(String name, int age){
                this.name = name;
                this.age = age;
        }
        public void setName(string name){
                this.name = name;
        }
        public string getName(){
                return name;
        }
        public void setAge(int age){
                this.age = age;
        }
        public int getAge(){
                return age;
        }


}

class Teacher extends Person{
        private double salary;
        //public void test(){
                //System.out.println(name);不能使用
        //}
        public Teacher(){
                super(null, 0);//默认值
        }
        public Teacher(String name, int age, double salary){
                super(name, age);//感觉和this(参数列表)的用法相似
                //根据继承的特征（3），这里super必须在首行
                this.salary = salary;
        }
}

class Student extends Person{
        private int score;
}

class Student extends Person{
        
}

/*
*方法的重写
*当子类继承了父类的方法时，但是父类的方法体不适用子类，可重写
*要求：（1）方法名必须与父类被重写的方法名相同
*（2）形参列表，必须和父类被重写的形参列表相同
*（3）返回值类型：基本数据类型和void要求与父类被重写的方法的返回值类型相同
*引用数据类型，要求子类重写的方法的返回值类型 <= 父类被重写的方法的返回值类型
*例如子类方法的返回值是Student，父类被重写方法的返回值类型是Student
*（4）修饰符
*1.权限修饰符，子类重写的方法的权限修饰符的可见范围 >= 父类被重写方法的权限修饰符的可见性范围
*例如：子类方法的修饰符是public，父类被重写方法的修饰符是protected
*2.其他修饰符（之后讲）
*/

public class test09_06{
        public static void main(String[] args){
                Manager m = new Manager("dfdf", 11, 23);
                System.out.println(m.getInfo());


        }
        
}

class Employee{
        //属性列表
        private String name;
        private double salary;
        //构造器
        public Employee(){

        }
        public Employee(String name, double salary){
                super();
                this.name = name;
                this.salary = salary;
        }
        //get、set
        public String getName(){
                return name;
        }
        public void setName(String name){
                this.name = name;
        }
        public double getSalary(){
                return name;
        }
        public void setSalary(double salary){
                this.salary = salary;
        }
        public String getInfo(){
                return "姓名： " + name + "工资： " + salary;
        }


}

class Manager extends Employee{
        //属性列表
        private double bonus;
        //构造器
        public Manager(){

        }
        public Manager(String name, double salary, double bonus){
                super(name, salary);
                this.bonus = bonus;
        }
        //get、set
        public void setBonus(double bonus){
                this.bonus = bonus;
        }
        public double getBonus(){
                return bonus;
        }
        //重写
        public String getInfo(){
                return "姓名： " + getName() + "工资： " + getSalary() + "奖金： " + bonus;
        }

        
}


/*
*Super 从父类中查找，引用父类的某某
*只能访问在父类中可见的属性、方法、构造器
*用法：1.super.属性  当子类声明了和父类同名的属性时，可以使用super属性来访问父类的属性
*2.super.方法 
*当子类中需要调用父类被重写的方法时，可以使用super.方法
*3.super()或super(实参列表)
*super()调用父类的无参结构
*super(参数列表)调用父类的有参结构
*必须在子类构造器的首行
*如果子类的构造器中没有写super()，它也存在
*但如果子类构造器中写了super(实参列表)，那么super()就不会存在了
*/
        

public class test09_06{
        public static void main(String[] args){        
                B b = new B();
                b.printNum(3);
        }
}

class A{
        int num = 1;
}
class B extneds A{
        int num = 2;
        public void printNum(int num){
                System.out.println(num);
                System.out.println(this.num);
                System.out.println(super.num);
        }

}


class Human{
        //属性
        private String name;
        private int age;
        //构造器
        public Human(String name, int age){
                super();//调用的是公共父类java.lang.Object类的无参构造
                this.name = name;
                this.age = age;
        }
        public Human(){

        }
        //get、set
        pulic String getName(){
                return name;
        }
        public void setName(String name){
                this.name = name;
        }
        pulic String getAge(){
                return Age;
        }
        public void setAge(int Age){
                this.Age = Age;
        }
        //方法
        public String getInfo(){
                return "姓名:" + name + "年龄:" + age;
        }
}


class XueSheng extends Human{
        private int score;
        //.......
        public String getInfo(){
                return super.getInfo() + "成绩：" + score；
        }
}