java笔记8-面向对象

　　终于到了java最重要的地方，这里先把概念简单的梳理一下，大部分的知识点会放在代码里面讲解，一提起面向对象，最容易想起来的就是类和对象。这两个概念比较简单，这里就不细讲了，不清楚的可以看下菜鸟教程中的图文解说，java面向对象的三大特性是封装、继承、多态。因此涉及到了很多权限的问题就有了权限修饰符

　　类由四部分构成：属性、方法、构造方法、块

　　修饰符分为特征修饰符和权限修饰符 特征修饰符有final、static、abstract、synchronized、votatile,、ransient 本节只说前两个；权限修饰符有四个public , protected,(默认不写), private权限的要求越来越高；

　　一些关键字的使用 this super extend。

//类的内部成员包含：属性 方法 构造方法  块(分为静态块,和普通块)
public class SonClass extends FatherClass {
    //构造方法的作用： 构造当前类的对象 可以在创建对象的同时做一些事情
    //构造方法的写法 权限修饰符 封装 方法名字  (参数列表){ 创建一个对象  返回对象}
    //类有默认的不传参的构造方法 如果自定义构造方法默认的会被覆盖 一个类可以有多个构造方法(方法重载)
    public SonClass(){
        //super指父类的"对象"  在子类构造方法中 第一行隐藏了super()  this和super不能同时在构造方法中同时出现,写了this，就没有super了
        //可以使用this调用本类的构造方法，只能在第一行
        this("yushengmin",18,"nan",new HandClass(5,4));
        System.out.println("我是SonClass类无参构造方法");
    }
    public SonClass(String name,int age,String sex,HandClass hand){
        //this用来代表当前调用方法时的那个对象  第一个name指的是成员变量  第二个那么指的是方法传参的name
        //this();
        super("父类的姓名");
        this.name=name;
        this.age=age;
        this.sex=sex;
        this.hand=hand;
        System.out.println("我叫"+name+"今年"+age+"岁，性别是"+sex+"我是SonClass类有参数的参构造方法");
    }
    //属性的修饰  访问修饰符 [特征修饰符final] 数据类型 属性名字 = [值]
    //实例变量声明在一个类中，但在方法、构造方法和语句块之外；
    //当一个对象被实例化之后，每个实例变量的值就跟着确定；
    //实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
    //实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
    //实例变量可以声明在使用前或者使用后；
    //访问修饰符可以修饰实例变量；
    //实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
    //实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
    //实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
    public String name;
    public int age;
    public String sex;
    //类属性的封装 不让用户随意修改，必须通过方法
    private int weight;
    //类中包含另一个类
    //一个类的对象当成另一个类的属性来存储
    ////如果用普通的构造方法 需要把类里面类的参数赋值 否则会报空指针错误
    // SonClass son = new SonClass();
    // son.name=""；
    // son.hand = new HandClass();
    //son.hand.number=5;
    //son.hand.length=4;
    //最好的方法是创建带参数的构造方法
    //SonClass son2 =new SonClass("于圣民",18,"男",new HandClass(5,4));
    public HandClass hand;
    //定义静态变量(类变量) 不赋值也有默认值
    //类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
    //无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
    //静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
    //静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
    //静态变量在第一次被访问时创建，在程序结束时销毁。
    //与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
    //默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
    //静态变量可以通过：ClassName.VariableName的方式访问。
    //类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
    public static  String country="中国";
    //一般设置或者获得私有属性的方法,大家默认的写成get、set
    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        if(weight>=160){
            System.out.println("我怎么可能这么胖，这货肯定不是我,请重新设置");
        }
        else{
            this.weight = weight;
        }

    }

    //权限修饰符封装   [特征修饰符final] 返回值类型 方法名字（参数列表)  [抛出异常]  [{方法体}]
    //抛出的异常(1、运行时异常 2、编译时异常)  运行时异常子类可以不予理会    编译异常 个数和类型小于等于父类
    //方法重写    权限子类可以大于等于父类
    // final(子类不能重写) static(子类不存在) abstract(子类不是抽象类必须重写)
    //子类的返回值是可以小于等于父类的返回值
    //子类的名字和参数必须与父类的名字一致
    public void draw(String star,int line){
        //局部变量声明在方法、构造方法或者语句块中；
        //局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
        //访问修饰符不能用于局部变量；
        //局部变量只在声明它的方法、构造方法或者语句块中可见；
        //局部变量是在栈上分配的。
        //局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
        for (int i=1;i<=line;i++)
        {
            for(int j=1;j<i+1;j++){
                System.out.print(star);
            }
            System.out.println();
        }
    }
    //方法重载 相同的方法名 参数个数和类型必须有一个不一致
    //数据类型可以自动转换 需要传int类型的方法也可以传递char类型的方法 byte,short,char—> int —> long—> float —> double
    //但是如果有传char类型的重载方法 优先调用传递char类型的方法

    public int calulator(int a,int b){
        return a+b;
    }
    public int calulator(int a){
        return a+1;
    }

    public char calulator(char a,char b){
        //char类型的计算会先转换成int，这里返回char类型，所以需要强制转换一下
        return (char)(b-a);
    }
    public int calulator(){
        return 0;
    }
    //可变参数（动态参数）列表  在方法的参数中只能存在一份 必须放在方法参数的后面
    //可变方法参数可以不传参数  如果有不传参数的重载方法，优先调用不传参数的方法。同理如果有传一个参数的重载，优先调用一个参数那个方法
    //和数组参数的调用方法一样 比数组参数好的地方是可以不传参数
    public int calulator(int...args){
        int s=1;
        for(int i=0;i<args.length;i++){
            s*=args[i];
        }
        return s;

    }
    public void useHandEatChichen(String name)
    {
        System.out.println("我叫"+this.name+"今年"+age+"岁，性别是"+sex+"我是SonClass类用手吃鸡的方法");
        System.out.println("我有"+hand.number+"根手指平均长度是"+hand.length);
        //在方法中调用另一个类，依赖关系
        ChichenClass chichen=new ChichenClass(name);
        chichen.beEat();
        hand.eatChichen();
    }


    //块的写法： 没有修饰符  没有参数 没有返回值 没有名字的特殊方法      {}
    //构造块  块是在调用构造方法之前执行，每调用一次构造方法就执行一次  可以写一些创建对象之前执行的东西
    //静态块  static{}  静态块只执行一次
    {
        System.out.println("我是SonClass类普通的构造块");
    }
    static{
        System.out.println("我SonClass类静态块");
    }




    public static void main(String[] args) {
        //创建对象的实质   通过new调用类的构造方法 得到了一个对象(构造方法的返回值) 然后把这个对象赋值给一个对象的名称son
        SonClass son = new SonClass();
        SonClass son1 =son;
        //创建对象son1在堆内存中没有开辟空间，直接指向了son的空间
        System.out.println(son.toString());
        System.out.println(son1.toString());
        SonClass son2 =new SonClass("民",18,"男",new HandClass(5,4));
        son2.useHandEatChichen("小鸡");
        son2.setWeight(180);
        int weight1=son2.getWeight();
        SonClass.testStatic();



    }

}

//权限修饰符public , protected,(默认不写)default, private
//权限修饰符   修饰：类和类中的成员(块除外) 修饰类的只有两个public或者不写
// 位置范围  同一个包的定义是package一模一样
//public       同类      同包    子类         当前工程任意位置都可以访问
//protected    同类     同包    子类(通过子类的对象在子类的范围内部才算)
//                            其他地方调用子类 在子类中实例化父类都不能调用protected方法属性
//默认         同类     同包
//private     同类
public class FatherClass {
    public String name;
    //final可以用来修饰变量、属性、方法、类
    //final修饰的全局变量必须赋初值  只声明 final int age;就会报错
    public final int age=36;
    //静态元素只有一份、如果某个对象或者类改变了这个值，其他对象调用的时候，会使用新的值
    public static String country="中国";
    public FatherClass(){
        System.out.println("我是FatherClass类无参构造方法");
    }
    public FatherClass(String name){
        this.name=name;
        System.out.println("我叫"+name+"我是FatherClass类有参构造方法");
    }
    public void draw(String star,int line){
        for (int i=1;i<=line;i++)
        {
            for(int j=1;j<i+1;j++){
                System.out.print(star);
            }
            System.out.println();
        }
    }
    //final修饰的方法不能被重写
    public final void testFinal(){
        //局部变量如果声明没有赋初始值,给一次存值的机会,因为变量在栈内存空间里没有默认值必须给一次赋值的机会
        final String a ;
        a="我是final修饰的方法不能被继承";
        System.out.println(a);
        //final修饰引用类型
        final int[] x=new int[]{1,2,3};
        //数组里面的内容是可以更改的 不能更改的是变量内的地址引用
        x[0]=10;
        System.out.println(x[0]);
        //不能再讲x数组的引用地址更改
        //x=new int[5];

    }
    public static void testStatic(){
        //static静态的
        // 可以修饰   不能修饰变量   可以修饰属性 修饰方法 修饰块 修饰内部类(不能修饰普通类)
        //修饰后的特点  修饰以后变成静态元素
        // 1、静态元素在类加载前就出现了，属于类
        // 2、存在静态元素区(每个类都有一个)
        // 3、静态元素只加载一次 全部类对象和类共享
        // 4、静态元素区加载的时候还没有对象 ，可以通过类名直接访问
        // 5、内存管理：栈内存创建开始用完回收  堆内存通过GC回收 静态元素区GC无法回收
        // 6、非静态成员可以访问静态成员
        // 7、静态成员可以访问静态成员
        // 8、静态成员不能访问非静态成员
        // 9、静态元素中不可以出现this super关键字
        System.out.println("我是静态方法,我可以通过类直接调用，那时候成员变量都还没有初值，所以我不能调用他们使用，但是我可以使用其他静态的方法属性");
        //同样的道理，因为this和super代表的是对象，所以不能在static环境中使用
        //System.out.println(this.country);
        testStaticOne();
    }
    private static void testStaticOne(){
        System.out.println("我是静态方法one,我的国籍是"+country);
    }





        {
        System.out.println("我是FatherClass类普通的构造块");
    }
    static{
        System.out.println("我FatherClass类静态块");
    }

}
//final修饰的类是不能被继承的
final class FatherClassOne{

}

public class ChichenClass {
    public String name;
    public ChichenClass()
    {

    }
    public ChichenClass(String name)
    {
        this.name=name;
    }
    public void beEat() {
        System.out.println("我是一只鸡,我的名字叫" + this.name + "我被吃了");
    }
}

public class HandClass {
    public HandClass()
    {

    }
    public HandClass(int number, int length)
    {
        this.number=number;
        this.length=length;
    }
    public int number ;
    public int length;

    public void eatChichen () {
        System.out.println("我是手的类吃鸡的方法");
    }


}

FatherClass类{
    属性 name age(final修饰长生不老)
    构造方法 有参 无参
    方法   draw(子类重写)、testFinal(final一些知识点)、testStatic、
    块:静态块 构造块
}
SonClass继承了父类FatherClass
    SonClass结构{
        属性：name、age、sex、对象hand、静态变量country
        方法：画画draw(重写父类)、计算的方法(四个重载共五种)、用手吃鸡的方法(调用鸡的类的被吃方法)
        构造方法：无参构造方法、有参构造方法
        块:静态块 构造块
}