Java面向对象

定义类：

定义类的语法如：

[修饰符] class 类名{
    零到多个构造器定义...
    零到多个Field（成员变量）...
    零到多个方法...
}

修饰符：public,final,abstract或者省略修饰符；

在类中，static修饰过成员不能访问没有static修饰成成员；

定义成员变量语法格式：

[修饰符] Field类型 Field名 [= 默认值];

修饰符可以省略，也可以是 public，protected，private，static，final（同色表示只能出现一个）

定义方法的语法格式：

[修饰符] 方法返回值类型 方法名(形参列表){
    //方法体
}

修饰符可以省略，可以是 public，protected，private，static， final，abstract

static

static是一个特殊的关键字，可用于修饰成员变量，成员方法；

static修饰的成员表明它属于这个类本身，而不属于该类的单个实例对象，故static修饰的成员变量，成员方法也成为类Field，类方法；不实用static修饰的叫实例对象，实例方法；

静态成员不能直接访问非静态成员；

final关键字

final关键字可以用来修饰类，变量和方法；

final修饰变量表示该变量获得了初始值久不可被改变；既可以修饰成员变量，也可以修饰局部变量，形参；

final修饰的方法不可被重写；

final类不可以有子类；

final修饰的成员变量必须有程序员显示地指定初始值；

方法的参数传递机制

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本传入方法内，而参数本身不会受到任何影响。

基本类型的参数传递：

public class test{
    public static void swap(int a,int b){
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("swap方法里,a的值是:"+a+",b的值是:"+b);
    }

    public static void main(String[] args){
        int a = 6;
        int b = 9;
        swap(a,b);
        System.out.println("交换结束后,a的值是:" + a + ",b的值是:" + b);
    }
}

输出结果：

swap方法里,a的值是:9,b的值是:6
交换结束后,a的值是:6,b的值是:9

引用类型的参数传递：

class D{
    public int a;
    public int b;
}

public class test{
    public static void swap(D x){
        int tmp = x.a;
        x.a = x.b;
        x.b = tmp;
        System.out.println("swap中,a的值是:"+x.a+";b的值是:"+x.b);
    }
    public static void main(String[] args){
        D d = new D();
        d.a = 6;
        d.b = 9;
        swap(d);
        System.out.println("交换结束后,a的值是:"+d.a+";b的值是:"+d.b);
    }
}

输出结果：

swap中,a的值是:9;b的值是:6
swap中,a的值是:9;b的值是:6

引用类型中，传递的也是值传递，由于是引用变量，传递的是地址，swap和main中操作的是指向同一地址的对象；

成员变量和局部变量

成员变量：在类范围里定义的变量，即Field；

1.实例成员变量：从该类的实例被创建开始存在，直到系统完全销毁这个实例；

2.类成员变量（加static）：从类的准备阶段就开始存在，知道系统完全销毁这个类，与这个类的生存范围一样。

一个类的实例修改类成员变量之后，其它实例访问类成员变量的值是修改之后的值；

class Person
{
    public String name;
    public static int num;
}

public class test
{
    public static void main(String[] args)
    {
        System.out.println("Person的成员变量num:"+Person.num);
        Person p = new Person();
        System.out.println("实例成员变量name:"+p.name+";num:"+p.num);
        p.name = "Dark";
        p.num = 2;
        System.out.println("p的成员变量name:"+p.name+";num:"+p.num);

        System.out.println("Person的成员变量num:"+Person.num);
        Person m = new Person();
        System.out.println("m的成员变量name:"+m.name+";num:"+m.num);
    }
}

输出结果：

Person的成员变量num:0
实例成员变量name:null;num:0
p的成员变量name:Dark;num:2
Person的成员变量num:2
m的成员变量name:null;num:2

局部变量：在方法里定义的变量；

局部变量根据定义形式 的不同，可以分为：

1.形参：在定义方法签名时定义的变量，形参的作用域在整个方法类有效；

2.方法局部变量：在方法体内定义的局部变量，它的作用域从定义该变量的地方生效，到该方法结束时失效；

3.代码块局部变量：在代码块中定义的局部变量；

局部变量除了形参外，都必须显示初始化，指定初始值，否则不可以访问；

public class test
{
    private String name = "Dark";
    private static double price = 78.0;
    public static void main(String[] args)
    {
        int price = 65;
        System.out.println(price);

        System.out.println(test.price);
        new test().info();

    }

    public void info(){
        String name = "White";
        System.out.println(name);
        System.out.println(this.name);
    }
}

输出结果：

65
78.0
White
Dark

封装

封装指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。

Java提供3个访问控制符：public，private，protected，还有一个不加任何访问控制符的访问控制级别default；

当不适用任何访问控制符来修饰类或类成员时，默认为default；

访问控制级别由小到大；

private<default<protected<public

private（当前类访问权限）：如果类里的一个成员使用private，该成员只能在当前类的内部被访问，最适合用来修饰Field；

default（包访问权限）：如果类里的一个成员或者一个外部类不使用任何访问控制修饰符，即包访问权限，default访问控制的成员或外部类可以被相同包下的其他类访问；

protected（子类访问权限）：若成员适用protected访问控制修饰符，该成员既可以被同一个包中的其他类访问，也可以被不同包中的子类访问；

public（公共访问权限）：若一个成员或外部类使用public访问控制修饰符，该成员或外部类就可以被所有的类访问，不论访问类和被访问类是不是处于同一个包，是否有继承关系；

封装实例：

class Person{
    private String name;
    private int age;

    public void setName(String name){
        if(name.length() > 6 || name.length() < 2)
        {
            System.out.println("您设置的人名不符合要求");
            return;
        }
        else
            this.name = name;
    }

    public String getName(){
        return this.name;
    }

    public void setAge(int age){
        if(age > 100 || age < 0)
        {
            System.out.println("您设置的年龄不合法");
            return;
        }
        else
            this.age = age;
    }

    public int getAge()
    {
        return this.age;
    }
}

public class test{
    public static void main(String[] args)
    {
        Person p = new Person();
        p.setAge(1000);
        System.out.println(p.getAge());

        p.setAge(30);
        System.out.println(p.getAge());

        p.setName("Dark");
        System.out.println(p.getName());
    }
}

继承

修饰符 class SubClass extends SuperClass{
    //类定义部分
}

重写父类方法：

——要方法名，形参列表相同；

若要调用被覆盖的方法，如果是实例方法是用super，类方法可以用父类类名；

class BaseClass
{
    public int a = 5;
}

public class SubClass extends BaseClass
{
    public int a = 7;
    public void toOwner()
    {
        System.out.println(a);
    }

    public void toBase()
    {
        System.out.println(super.a);
    }

    public static void main(String[] args)
    {
        SubClass m = new SubClass();
        m.toOwner();
        m.toBase();
    }
}

输出结果：

7
5

继承时构造器之间的调用关系

class Creature{
    public Creature(){
        System.out.println("Creature无参数的构造器");
    }
}

class Animal extends Creature{
    public Animal(String name){
        System.out.println("Animal带一个参数的构造器,该动物的name为:"+name);
    }

    public Animal(String name,int age){
        this(name);//使用this调用同一个重载的构造器
        System.out.println("Animal带两个参数的构造器,其age为:"+age);
    }
}


public class Wolf extends Animal{
    public Wolf(){
        super("灰太狼",3);
        System.out.println("Wolf无参数的构造器");
    }

    public static void main(String[] args){
        new Wolf();
    }
}

result:

Creature无参数的构造器
Animal带一个参数的构造器,该动物的name为:灰太狼
Animal带两个参数的构造器,其age为:3
Wolf无参数的构造器

多态

父类声明，子类实现；即：

BaseClass test = new SubClass();

当把一个子类对象直接赋给父类的引用变量时，当运行时调用该引用变量的方法时，其方法行为总时表现出子类方法的行为特征，而不是父类方法的行为特征；

对象的Field不具备多态性；

包装类

Java为8个基本类型提供了对应的包装类，通过这些包装类可以把8个基本类型的值包装成对象使用；

int为Integer，char为Character，其他只是改变为首字母大写；

    public static void main(String[] args) {
        boolean b = true;
        Boolean bObj = new Boolean(b);
        
        int i = 5;
        Integer IntObj = new Integer(i);
        
        Float f = new Float("4.56"); //把字符串转换成Float对象
        Boolean bbObj = new Boolean("false");
    }

包装类实现基本类型变量和字符串之间的转换：

抽象

抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类可以没有抽象方法；

规则：

1.抽象方法不能有方法体；

2.抽象类不能被实例化；

3.抽象类可包含Field，方法，构造器，主要用于被子类调用；

接口

接口是一种特殊的抽象类，接口里不能包含普通方法，其中所有的方法都是抽象方法；

接口的定义：

[修饰符] interface 接口名 extends 父接口1，父接口2...
{
    零到多个常量定义...
    零到多个抽象方法定义...
}

使用接口：

[修饰符] class 类名 implements 接口1，接口2...
{
    类体部分...
}

内部类

。。。。

引用类型数组的初始化

class Person{
    public int age;
    public double height;

    public void info(){
        System.out.println("My age is:" + age +",My heght is:" + height);
    }
}

public class test{
    public static void main(String[] args){
        Person[] students = new Person[2];
        Person zhang = new Person();
        zhang.age = 15;
        zhang.height = 158;

        Person lee = new Person();
        lee.age = 16;
        lee.height = 161;

        students[0] = zhang;
        students[1] = lee;

        lee.info();
        students[1].info();
    }
}