java笔记（四）

面向对象，java的三大特性：封装、继承、多态

1：封装

（1）（封装性的思想）①将类的属性私有化 private，②提供公共的方法（setter & getter）来实现调用。
例子：

/*
 * 创建程序，在其中定义两个类：Person和TestPerson类。
 * 定义如下：
 * 用setAge（）设置人的合法年龄（0~130），用getAge返回
 * 人的年龄。在TestPerson类中实例化Person类的对象b，
 * 调用setAge（）和getAge（）方法，体会java的封装性
 */
public class TestPerson {
    public static void main(String[] args){
        Person p =new Person();     
        p.setAge(155);
        System.out.println(p.getAge());
    }
}

class Person{
    private int age;

    public int getAge(){
        return age;
    }

    public void setAge(int i){
        if(i > 0 && i <= 130){
            age = i;
        }else{
            System.out.println("您输入的数据有误");
        }
    }

}

---

2：继承

1.通过”class A extends B”类实现类的继承。
子类：A 父类（或基类 SuperClass）：B

2.子类继承父类以后，父类中声明的属性、方法，子类就可以获取到。
明确：当父类中有私有的属性或方法时，子类同样可以获取得到，只是由于封装性的设计，使得子类不可以直接
调用罢了。

3.子类除了通过继承，获取父类的结构之外，还可以定义自己的特有的成分。

extends：子类是对父类功能的“扩展”，明确子类不是父类的子集。

例子

public class Father {
    public int getMoney(){
        System.out.println("父亲一个月挣3万");
        return 30000;
    }
}

public class Son extends Father {
    public static void main(String[] args) {
        Son c = new Son();
        c.getMoney();       //调用父类赚钱的方法
    }   
}

3：多态（我的理解是父类的多种表现形态）

一、要有继承

二、要有重写

三、父类引用指向子类对象

例子

public class Father2 {
    public int getMoney(){
        System.out.println("父亲一个月挣3万");
        return 30000;
    }
}

public class Businessman extends Father{
    public int getMoney() {
        System.out.println("孩子做生意挣钱，一个月1万");
        return 10000;
    }
}

public class Soldier extends Father{
    public int getMoney(){
        System.out.println("白领，一个月挣18000");
        return 18000;
    }
    public static void main(String[] args) {
        Father f = new Child();
        Father f2 = new Businessman ();
        f.getMoney();
        f2.getMoney();
    }
}

重载
1.同一个类中
2.方法名必须相同
3.方法的参数列表不同（①参数的个数不同②参数类型不同）
4.：方法的重载与方法的返回值类型没有关系！

例子

public class Overload {

    public static void overload(int i,int j){
        i += j;
        System.out.println(i);
    }

    public static void overload(double i,double j){
        i += j;
        System.out.println(i);
    }

    public static void main(String[] args) {
        overload(2, 3);         //输出结果为5
        overload(2.2, 3.2);     //输出结果为5.4
    }
}

重写 override orverwrite
1.：在继承的基础之上，子类在获取了父类的结构以后，可以对父类中同名的方法进行“重构”
2.方法的返回值，方法名，形参列表形同；
3.权限修饰符不小于父类的同名方法；
4.子类方法的异常类型不大于父类的；
5. 两个方法要同为static或同为非static。

例子：

public class Override {
    public void teacher(){
        System.out.println("教数学");
    }
}

public class SonTeacher extends Override{   //继承Override
    public void teacher() {
        System.out.println("教语文");
    }
    public static void main(String[] args) {
        Override t = new SonTeacher();
        t.teacher();   //实现覆盖，显示的是教语文
    }
}

抽象类
abstract：抽象的，可以用来修饰类、方法

• 1.abstract修饰类：抽象类
• 1)不可被实例化
• 2)抽象类有构造器 (凡是类都有构造器)
• 3)抽象方法所在的类，一定是抽象类。

• 4)抽象类中可以没有抽象方法。

• 当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就可以实例化

• 2.abstract修饰方法：抽象方法

• 1)格式：没有方法体，包括{}.如：public abstract void eat();
• 2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
• 3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个”实体类”,即可以实例化
• 4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！

/**
 * 抽象类的特殊：
 * 1：有抽象方法的时候，类的修饰符必须有一个abstract标志
 * 2：抽象类可以不定义抽象方法
 * 3：抽象方法是没有大括号的。
 * 4：这个类是不能new的
 * 5：子类必须实现抽象类的方法
 */

public abstract class Father {
      //一个方法定义成抽象的方法。这个类就叫抽象类
    public abstract void goToSchool();
}

//子类继承父类
public class WorkerChild extends Father {

    @Override
    public void goToSchool() {
        System.out.println("去大学");
    }

    public static void main(String[] args) {
        WorkerChild wkc = new WorkerChild();
        wkc.goToSchool();
    }
}

接口

• 接口（interface） 是与类并行的一个概念
• 1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
• 2.接口是没有构造器的。
• 3.接口定义的就是一种功能。此功能可以被类所实现（implements）。
  比如：class CC extends DD implements AA
• 4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
• 5.类可以实现多个接口。—-java 中的类的继承是单继承的
• 6.接口与接口之间也是继承的关系，而且可以实现多继承
• >5,6描述的是java中的继承的特点。

• 7.接口与具体的实现类之间也存在多态性

  例子

/**
 * 1：接口是用interface修饰
 * 2：方法不能有实现（不能有大括号）
 * @author Administrator
 */
//接口
public interface Teacher {

    //方法
    public void read();
    public void write();
}

//implement实现接口
public class Student implements Teacher {

    @Override
    public void read() {
        System.out.println("读了一本书");
    }

    @Override
    public void write() {
        System.out.println("写了一篇作文");
    }
    //使用接口定义的变量，只能调用此接口具备的方法，无法调用其他接口有的方法
    public static void main(String[] args) {
        Teacher t = new Student();
        t.read();
        t.write();
    }

成员内部类
成员内部类，就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。
成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己的。

例子

public class Other {
        public static void main(String[] args) { 
            Other outer = new Other(); 
            Other.Inner inner = outer.new Inner(); 
            inner.print("Outer.new"); 
        } 

        public class Inner { 
            public void print(String str) { 
                System.out.println(str); 
            } 
        } 
}

内部类
内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。

静态内部类
static修饰的内部类就是静态内部类

匿名内部类
匿名内部类也就是没有名字的内部类
匿名内部类只能使用一次，它通常用来简化代码编写
但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

例子

    //多线程用匿名内部类的写法
       public static void test(){
           Thread t = new Thread(new Runnable() {

            @Override
            public void run() {     
            }
        });
       }