封装，继承，重写

封装的作用和意义

 1提高程序的安全性，保护数据。
    2. 隐藏代码的实现细节
    3. 统一用户的调用接口
    4. 提高系统的可维护性
   5. 便于调用者调用。

封装：禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，也可称作信息隐藏

高内聚就是类的内部数据操作细节自己完成，不允许外
           部干涉；低耦合：仅暴露少量的方法给外部使用。

调用类：

在类中的话也是，非静态之间，静态类之间可以互相调用； 非静态类也可调用静态类(这里的类中不一定是主函数main中，也可以是其他类中)

任何一个类最上层的父类都是Object。

protected:

1. 父类的被protected修饰的类成员包内可见，并且对其子类可见。
2. 父类与子类不在同一个包里，子类只可以访问从父类继承的protected成员，不能访问父类实例化的成员。

private属性私有属性：private不能用于外部类的封装，但是可以用于内部类的封装

被其修饰的类成员只能在修饰它的类中被访问，私有化成员一般用于封装，不可以被外部类访问，对外提供get/set方法对其进行访问。
可使用一下方法访问
在类中提供对于get和set方法
可以让用户在类的外部可以间接的访问私有属性
set负责给属性赋值
get负责返回属性的值

继承

java中子类继承父类,使用关键字extends来表示。
public class 子类名称 extends 父类名称<==格式

JAVA中类只有单继承，没有多继承！ 接口可以多继承！

1.继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
2. 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来
表示。

子类继承能否调用方法

1.父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
2.父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用
3.父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用
super关键字)。

//最大类Object;任何一个类最上层的父类都是Object。

重写

重写有方法重载和方法重写

方法重载

类中有多个方法,有着相同的方法名,
但是方法的参数各不相同,这种情况被称为方法的重载。
方法的重载可以提供方法调用的灵活性。 */


方法重载满足的条件
1.方法名必须相同
2.参数列表必须不同(参数的类型、个数、顺序的不同)

在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表==>也可改变调用的类型

方法重写

一. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不
能被重写.
二. 静态方法不能重写
1. 父类的静态方法不能被子类重写为非静态方法 //编译出错
2. 父类的非静态方法不能被子类重写为静态方法；//编译出错
3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
三.重写的语法
1. 方法名必须相同
2. 参数列表必须相同
3. 访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
4. 抛出异常类型的范围可以被缩小,但是不能被扩大
ClassNotFoundException ---> Exception
5. 返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回
类型的子类型
例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的
子类型

public class lei_3大特征 {
   
    public static void main(String[] args) {
        Student s = new Student(); //类中的话也是，非静态之间，静态类之间可以互相调用
        // 非静态类也可调用静态类
        s.name = "tom";
        s.println();//调用方法中的打印
        s.setName("xiaobai");
        System.out.println(s.getName());
        System.out.println("任何对象"instanceof Object);
        System.out.println("
");
        // 调用继承父类中子类的方法
        // cannot be resolved to a type
        Student11  s11 = new Student11(); //好吧，这方法不能调用，说类没有属性
        s11.tes("chuanrude1canshu");
        System.out.println("
");
        s11.test();
            
        
        //任何一个类最上层的父类都是Object。
        //输出结果:true
        //注:任何对象也包含数组对象

      
        

    }
    //对象能在类的外部"直接"访问
    public static class Student{
    public String name; //定义全局变量name么
    public void println(){
        System.out.println(this.name);
    }
    
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    }
    //方法重载
    /*类中有多个方法,有着相同的方法名,
    但是方法的参数各不相同,这种情况被称为方法的重载。
    方法的重载可以提供方法调用的灵活性。 */
    
    //方法重载满足的条件
    /*1. 方法名必须相同
      2. 参数列表必须不同(参数的类型、个数、顺序的不同)
 */
   //在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表==>也可改变调用的类型


   //继承
   /*JAVA中类只有单继承，没有多继承！ 接口可以多继承！ */
   /*
   1.继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
   2. 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来
表示。
 */
    //子类继承能否调用方法
    /*1.父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
    2.父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用
    3.父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用
super关键字)。
    //最大类Object;任何一个类最上层的父类都是Object。
 */


    //编译后,Person类会默认继承Object
    public static class Person{
        protected String name = "父类name11";//protected干嘛的:继承的类可以访问
        // public String name;
        
        public void print(){
            System.out.println("父类中打印的Person");
            }

        //这就是java中的构造器，类中public 类名(定义属性){this 属性}
        // public Person(String name){
        //     this.name = name;
        //     }    

    }
    //Student11是间接的继承了Object
     //调用子类中的属性和方法
    /*子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问
或调用父类中的属性和方法。 */
    public static class Student11 extends Person{
        // public Student11(){
        //     super("super调用父类中的结果");//super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）
        //     }//super后改的是父类中的name值，没有的话就是赋值给父类
        //private不能用于外部类的封装，但是可以用于内部类的封装

        private String name = "子类si"; //private(私有)关键字把数据隐藏起来
        // public String name;
       /*额可以设置set，get方法访问属性
       通过set方法，命名格式： set属性名（）; 属性的首字母要大写
访问 通过get方法，命名格式： get属性名（）; 属性的首字母要大写
 */
        public void tes(String name){
            //访问父类中的属性
            System.out.println("这个是传进去的参数"+name);
            System.out.println("这个是调用子类中本身被定义的属性"+this.name);
            System.out.println("父类中属性name但父类中没有name属性"+super.name);
            }    
        
        public void print(){
            System.out.println("子类中打印的Student");
            }
        
        public void test(){
        print();
        //this调用自身子类
        this.print();
        //【调用父类中的方法】
        super.print();
        }
    
        //编译通过,子类构造器中会隐式的调用父类的无参构造器
        //super();

        // public Student11(){//这里报错，缘由是
        //     //父类中已经有参数构成 protected String name = "zs";
        // }

        ////但可以通过super调用,子类构造器中显式的调用父类的有参构造器

        /*注意：super调用，this调用都需要出现在类中的第一位
        不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和
super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。 */
        // public Student(){
        //     super("tom");
        //     }
     
        

        //方法重写(override)
        /*
        1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不
能被重写.
        2. 静态方法不能重写
            1. 父类的静态方法不能被子类重写为非静态方法 //编译出错
            2. 父类的非静态方法不能被子类重写为静态方法；//编译出错
            3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
        3.重写的语法
            1. 方法名必须相同
            2. 参数列表必须相同
            3. 访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
            4. 抛出异常类型的范围可以被缩小,但是不能被扩大
            ClassNotFoundException ---> Exception
            5. 返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回
            类型的子类型
            例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的
            子类型    
            */
                        
  

   

        }


  
}