【10/12】Java类的一些阶段小总结

Java写代码的小疑惑

数组

数组扩容：原来的数组长度固定，无法扩容，只需定义一个新的数组使其长度始终为原来数组的长度+1

int []arr ={1,2,3};
int arrNew= new int [arr.length+1];
arr = arrNew;
//arr直接指向arrNew

开辟原理就是数组的容量不能变，只能用一个新的数组去承接原来的数组

面向对象编程

类和对象

对象分为静态部分和动态部分，比如人，有身高，体重等数据，人也具有跑动，进食等行为。

识别完对象的属性和行为后，对象就被定义完成了，将对象的属性和行为封装起来，就形成了一个类

类本质上就是封装对象的属性和行为的载体，对象就是类抽象的实例

例如：人类封装了人一切的属性和行为

封装

封装就是，用计算机实现一些功能，而无需知道计算机内部是如何工作的

类就是将内部的数据隐藏，为用户呈现的是对象的属性以及行为的接口，例如敲键盘操作电脑，键盘就是一个接口，原理就是通过接口使用这些类，无需知道内部是如何构成的，无法对类的内容数据造成影响。

继承

例如，人类中的人种，具有肤色，社会行为等特色属性，但是人种之间的大部分属性还是相同的，比如亚洲人，为亚洲人类，保留了人类的相关属性和行为，这样就能节省定义亚洲人类和人类相同属性和行为的时间，这就是继承的思想。

所以继承行主要就是利用特定对象之间的共有属性，同时又添加了独有的属性和行为

Java语言中有子类和父类的区分，子类的实例都是父类的实例，但是父类的实例不一定是子类的实例

因此，继承关系一般都可以用树形关系来表示

多态

父类对象应用于子类的特征就是多态，多态的实现依赖抽象类和接口

类

Java中使用class关键字来定义类，对象的属性用成员变量来表示，对象的方法用成员的方法来表示

java中类的定义与对象的创建

格式：修饰符 class 类名 {

成员变量；

成员方法；

}

类名用大写的英文表示，类是模具和图纸，对象就是成型的模型

class Person {//person中就是对类的定义
    public int age;//成员属性 实例变量
    public String name;
    public String sex;
    public void eat() {//类中的函数称为成员方法
       System.out.println("吃饭!");  
   }
    public void sleep() {
       System.out.println("睡觉!");  
   }
}

接着使用类创建一个对象

Person person = new Person();//实例化一个对象

成员变量和局部变量的区别

成员变量具有默认值，而局部变量需要自己复制后才能使用

java中getter和setter的用法

setter方法：主要用于对属性内容的设置与修改，一般和this配合

getter方法：主要用于对属性内容的取得，一般和return配合

public和private 的区别

public表示公共成员，完全公开，没用访问限制

private表示，私有成员，在类的内部才能访问

class  B   extends  A{
    private  String sex;
    public  String getSex(){
        return   sex;
    }
    public  void  setSex(String sex)
    {
        this.sex=sex;//对成员变量sex进行初始化
    }
}

this的用法

this表示本类当前的对象（正在编辑的类），所以this关键字只能在本类中使用，用来调用成员变量和成员方法

例如：

static class Student{
//        成员变量
        String name;
        int score;
        int number;  //记录录入顺序
//为上面的三个变量初始化
        public Student(String name, int score, int number) {
//            分别设置学生的姓名,分数,数量
            this.name = name;//左边的name为成员变量，右边的name为形参
            this.score = score;
            this.number = number;
        }
}

this.变量就是指相应的成员变量，相当于把形参值赋给成员变量

构造方法

例如：

  public carPerson(int id, String name, int age, Hand hand){
        this.id = id;
        this.age = age;
        this.name = name;
        this.hand=hand;
    }

先构造，再用getter和setter用法，用来从测试类导入数据

单例模式的最基本实现

例如：

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

接口和抽象类

接口是一个面向对象分析与设计的必然结果，而抽象类则是重构的结果，也可以理解为先有接口，后有抽象类

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

2、抽象类要被子类继承，接口要被类实现。

3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果

7、抽象类里可以没有抽象方法

8、如果一个类里有抽象方法，那么这个类只能是抽象类

9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

10、接口可继承接口，并可多继承接口，但类只能单根继承。

​ 在java中，可以通过对象的多态性，为抽象类和接口实例化，这样再使用抽象类和接口的时候就可以调用本子类中所覆写过的方法。
　　之所以抽象类和接口不能直接实例化，是因为其内部包含了抽象方法，抽象方法本身是未实现的方法，所以无法调用。

abstract class A{    // 定义抽象类A
    public abstract void print() ;    // 定义抽象方法print()
};
class B extends A {    // 定义子类，继承抽象类
    public void print(){        // 覆写抽象方法
        System.out.println("Hello World!") ;
    }
};
public class AbstractCaseDemo01{
    public static void main(String args[]){
        A a = new B() ;        // 通过子类为抽象类实例化，向上转型。
        a.print() ;
    }
};
运行结果：
Hello World!

为接口实例化

package com.zhijin;
interface A{    // 定义抽象类A
    public abstract void print() ;    // 定义抽象方法print()
};
class B implements A {    // 定义子类，继承抽象类
    public void print(){        // 覆写抽象方法
        System.out.println("Hello World!!!") ;
    }
};
public class ThisDemo06{
    public static void main(String args[]){
        A a = new B() ;        // 通过子类为抽象类实例化
        a.print() ;
    }
};

所以，如果想要使用抽象类和接口，则只能按照以上操作完成。

内部类的扩展

abstract class A{    // 定义抽象类
    public abstract void printA() ;    // 抽象方法
    interface B{    // 定义内部接口
        public void printB() ;    // 定义抽象方法
    }
};
class X extends A{    // 继承抽象类
    public void printA(){
        System.out.println("HELLO --> A") ;
    }
    class Y implements B{    // 定义内部类实现内部接口
        public void printB(){
            System.out.println("HELLO --> B") ;
        }
    };
};
public class InnerExtDemo01{
    public static void main(String args[]){
        A.B b = new X().new Y() ;　　//参考前面内部类的知识，实现内部类实例的方法：外部类.内部类  内部类对象= 外部类对象.new  内部类
        b.printB() ;
    }
};
运行结果：
HELLO-->B