Java面向对象

[图片上传中...(null与GC.PNG-72a05e-1543754889476-0)]

1.类

类的定义.PNG

.

类的实例化.PNG

.

2.成员变量与局部变量

.

成员变量与局部变量.PNG
.
int 、double、float默认值为0,String默认值为null,Boolean默认值为false.

3.null与GC

image.png

4.private/public

private public.PNG

Javabean规范：
把成员变量声明为private,读取时使用getxxx方法,设置时使用setxxx方法

private访问权限：只能在当前类中访问

5.构造函数

构造函数.PNG

构造函数的名与类名字一致，没有返回值
在new xx 时被调用
一旦定义一个构造函数，则默认的无参函数将不会提供
.

public class person {

    private int age;
    private String name;
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return this.age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
    
    public person(){           //构造函数
        this.age=5;
        this.name="xxx";        
    }
    
    public static void main(String[] args){
        person p=new person();
        System.out.println("age="+p.age+" "+"name="+p.name);
    }
}

.

6.JavaBean 规范

最好遵循此规则

JavaBean规范.PNG

字段正常用private
.

7.package(包)

包.PNG example.PNG

\\import java项目名.包名.类名
import OOP.text1.person

.

8.静态static

static静态.PNG

public class Person {
    //声明一个static
    public static int population=0;    
    
    public Person(){
        population++;
    }
    
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
}

package text1;

public class oopText1 {

    public static void main(String[] args) {
        Person p1=new Person();
        System.out.println(Person.population);
        Person p2=new Person();
        System.out.println(Person.population);
        Person p3=new Person();
        System.out.println(Person.population);
    }

}

result:

result1.PNG
.
可以被别的类调用

package text1;

public class oldPerson {
    //调用Person的static
    public oldPerson(){
        Person.population--;
    }
    
}

.
可将static设为“只能读不能写”

//只能读不能写
    public final double pi=3.14;

.
static中不能调用this.
非静态可调用静态量（static），静态不可调用非静态(static)

9.单例模式

单例模式.PNG

package singleton;

public class God {
    //声明一个静态对象
    private static God instance=new God();
    
    //提供一个访问这个对象的static方法
    public static God getGod(){
        return instance;
    }
    
    //把构造函数设为private
    private God(){
        
    }
}

God.getGod();                \\调用单一类对象God

.
无参构造函数中运用this()调用重载构造函数

public class ps {
    //构造函数中可用this()调用重载构造函数，且必须为构造函数中的第一行代码
    public ps(){
        this(0);
    }
    
    public ps(int i){
        System.out.println(i);
    }
}

.

10.枚举（enum）

枚举.PNG

public enum dir {
    //枚举的范围有且只有几个
    right,left,up,down
}

public static void main(String[] args) {
        dir d=dir.down;
        System.out.println(d);
    }

枚举原理：

public class dirSouce {
    private dirSouce(){
        
    }
    
    public static final dirSouce up=new dirSouce();         //创建静态对象
    public static final dirSouce down=new dirSouce();
    public static final dirSouce left=new dirSouce();
    public static final dirSouce right=new dirSouce();
}

static只能初始化一次
.

11.类的静态代码块

类的静态代码块.PNG

在类第一次被使用时执行一次，且在构造函数执行之前执行。有且执行一次

package classStatic;

public class text1 {
    
    static{
        System.out.println("静态代码块2");
    }
    
    public text1(){
        System.out.println("构造函数");
    }
    
    static{
        System.out.println("静态代码块1");
    }
}

package classStatic;

public class ps {
    public static void main(String[] args) {
        text1 a=new text1();
        text1 b=new text1();
        System.out.println(a);
        System.out.println(b);
    }
}

result:

result2.PNG

.

12.继承（Inherit）

继承（inherit).PNG

继承非private成员

//父类
public class animal {
    public void eat(){
        System.err.println("I can eat!");
    }
}

//子类
public class human extends animal {
    public void speak(){
        System.out.println("I can speak!!");
    }
}

public class text2 {

    public static void main(String[] args) {
        human t=new human();
        t.eat();
        t.speak();
    }

}

result:

result3.PNG

.

继承中的构造函数调用顺序.PNG

1.子类创建对象时都会先调用父类的构造函数，再执行自身的构造函数
2.子类无调用父类的重载构造函数，则默认调用父类默认的无参构造函数，相当于super()(前面不能有其他代码）
3.可用super(""/int/double...)调用父类的重载构造函数
4.如果父类没有无参构造函数，则子类必须调用父类的重载构造函数
.

13.private/public/protected

private public protected.PNG

default:

void xxx(){               //default
}

重载问题：调用最接近它的类型（如int,如有object与int,则调用int.如无int，则掉object）

14.多态

多态.PNG

调用时如子类无此方法，则调用父类的此方法。如有，则调用子类自身的此方法

多态2.PNG

.
1.父类类型变量可以指向子类对象，子类类型变量不可以指向父类变量*

    DiQiuRen d=new Chinese();

2.通过父类类型的变量调用一个override类型的方法时，调用的是子类对象的方法。
3.能调用什么方法由变量类型决定，执行谁的方法由指定的对象决定

在override前加@override是个标注，避免函数名写错
.

15.父子类间类型转换

类型转换.PNG

public static void main(String[] args) {
        Chinese c1=new Chinese();
        DiQiuRen c2=c1;
        Chinese c3=(Chinese)c2;    //强制类型转换
    }

super.xxx()表示引用父类的xx方法
this.xx()表示调用当前对象的方法

16.final用法

1.public static final int a=9; 除初始化外，a不能再被修改
2.final 方法，此方法不能再被子类override
3.final 类，此类不能有子类

17.抽象类

抽象类.PNG

//父类抽象，speak方法由子类完成
abstract public class DiQiuRen {
    public abstract void speak();
    
    public void eat(){
        System.out.println("ciciici");
    }
}

public class Chinese extends DiQiuRen {
    //完成父类的speak()方法
    @Override
    public void speak() {
        System.out.println("我是中国人！");

    }

}

.

抽象类子类.PNG

子类必须实现父类的抽象方法，如不实现，要定义成abstract，由子类继续实现

18.匿名内部类

匿名内部类.PNG

public static void main(String[] args) {
        
        DiQiuRen d0=new DiQiuRen();
        System.out.println(d0.getClass());
        
        DiQiuRen d1=new DiQiuRen(){};
        System.out.println(d1.getClass());
        /*等效于：
        class text1$1 extands DiQiuRen(){
        }
        DiQiuRen d1=new text1$1();  
     */
    }

public static void main(String[] args) {
        
        DiQiuRen d1=new DiQiuRen(){
            @Override
            public void speak() {
                System.out.println("I`m the son of DiQiuRen!");
            };
            
            //不能被调用，无意义
            public void go(){           
                this.speak();         
            }
        };
        
        d1.speak();
        d1.go();     //不能调用匿名子类中的方法，因变量类型为父类
    }

匿名类可以定义抽象类的子类，且必须完成抽象类的方法
可直接访问局部变量
.

匿名内部类访问局部变量.PNG

public class text3 {

    public static void main(String[] args) {
        text3 t1=new text3();
        t1.setAge(8);
        t1.f1();
    }
    
    private int age;
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void f1(){
        DiQiuRen d1=new DiQiuRen() {
            
            @Override
            public void sayName() {
                int age=7;
                System.out.println(age);
                System.out.println(text3.this.age);   //调用外部类的成员变量
                
            }
        
        };
        d1.sayName();
    }

}

可用类名+this.xx调用外部类成员变量
.

19.接口

接口.PNG

public interface Speakable {    //接口
    void speak();
    void cry();
}

public class man implements Speakable{   //类man实现Speakable接口
    public void speak(){
        
    }
    
    public void cry() {
        
    }
}

.

接口2.PNG

20.异步

GameCore.asyncRun();

GameCore.asyncRun(new Runnable() {
                
                @Override
                public void run() {
                    // TODO 自动生成的方法存根
                    
                }
            });
        }

.

21.回调（addKeyListener）

.
在合适的时机进行调用，不需一直判断

GameCore.addKeyListener(new KeyListener() {
                
                @Override
                public void keyTyped(KeyEvent e) {
                    // TODO 自动生成的方法存根
                    
                }
                
                @Override
                public void keyReleased(KeyEvent e) {
                    // TODO 自动生成的方法存根
                    
                }
                
                @Override
                public void keyPressed(KeyEvent e) {
                    //按键抬起时执行
                    
                }
            });