Java学习笔记四

1. 包和导包

包：本质是一个文件夹，在代码中需要写package 包名

导包：

import 包 . 类;

不需要导包的情况：

1. 在自己的包内

2.java.long包下的所有内容不需要导包

        String

        System.out.println()

2. 访问权限

1. public 公共的

2. default 包访问权限，在自己包内可以随意访问，别的包不可访问

3. private 私有的

//com.xyq.entity中  包括类 Person的定义
package com.xyq.entity;

public class Person {
    public String pub = "public";
    private String pri = "private";
    String def = "default";

    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.pub);
        System.out.println(p.pri);
        System.out.println(p.def);
    }
}

 输出结果：

public
private
default

// com.xyq.entity 中另一个类定义文件
package com.xyq.entity;

public class TPerson {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.pub);
        System.out.println(p.pri); //报错
        System.out.println(p.def);
    }
}

编译结果：

System.out.println(p.pri); 报错

//另一个包 com.xyq.daobao 中
package com.xyq.daobao;     //包的声明
import com.xyq.entity.Person;  // 导包
public class TestPerson {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.pub);
        System.out.println(p.pri);  // 报错
        System.out.println(p.def);  // 报错
    }
}

 编译结果：

System.out.println(p.pri);
System.out.println(p.def);

   编译报错

 用的最多的是 public 和 private 。

3. getter 和 setter

自动生成：右键 -> generate -> getter and setter -> 全选 -> ok。

4. 继承

继承：子类可以自动拥有父类中除了私有内容外的其他所有内容。

当出现 x 是一种 y 的时候，x 就可以继承 y 。

public class 类 extends 父类 {

}

黑熊怪是一种妖怪。

// YaoGuai.java
package com.xyq.yaojing;

public class YaoGuai {
    private void paSi(){
        System.out.println("妖怪怕死");
    }
    public void chiRen()
    {
        System.out.println("吃人");
    }
}



// HeiXiongJing.java
package com.xyq.yaojing;

public class HeiXiongJing extends YaoGuai{

}



// test.java
package com.xyq.yaojing;

public class test {
    public static void main(String[] args) {
        HeiXiongJing hx = new HeiXiongJing();
        hx.chiRen();


        hx.paSi(); 
    }
}

        hx.paSi();   报错    ---------- 私有内容不能继承

 5. super关键字

super：表示父类中的内容

this：表示自己类中的内容

用 super 和 this 区分父类和子类重名的内容。

创建对象的过程： 先创建父类的对象，然后创建子类的对象。

super() ;     调用父类构造方法

this();          调用本类构造方法

6. 多态

//Animal 是 Cat、Dog、Bird 父类

Animal ani = new Cat();  // 把子类的对象赋值给父类的引用(变量)，向上转型

// Animal.java
public class Animal {
    public void eat() {
        System.out.println("动物在吃");
    }
}




// Cat.java
public class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}



// Dog.java
public class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }
}



// Bird.java
public class Bird extends Animal{
    public void eat(){
        System.out.println("鸟吃米");
    }
}





// Person.java
public class Person {

    public void feed(Animal ani){ // 接收到的所有动物都是 Animal
        ani.eat();
    }

    public static void main(String[] args) {
        Animal ani1 = new Cat();  // 把子类的对象赋值给父类的引用（变量） 向上转型
        Animal ani2 = new Dog();
        Animal ani3 = new Bird();

        Person p = new Person();
        p.feed(ani1);
        p.feed(ani2);
        p.feed(ani3);

    }
}

多态：把不同的数据类型进行统一

输出结果：

猫吃鱼
狗吃骨头
鸟吃米

1. 把子类的对象赋值给父类的对象 -> 向上对象

        缺点：会屏蔽掉子类中特有的方法

2. 把父类的对象转化回子类的对象 -> 向下转型

    向下转型有可能有风险，java要求必须要写强制类型转换

  （转换后的数据类型）变量

//向下转型
Cat cc = (Cat) ani1;
cc.catchMouse();
((Cat) ani1).catchMouse();
// ani1.catchMouse(); 报错

 7. final关键字

1. 被 final 修饰的变量不可以被改变

2. 被 final 修饰的方法不可以被重写

3. 被 final 修饰的类不可以被继承

8. 抽象类

抽象：只声明，不实现。

public abstract class Animal {  //类中有抽象方法，那么这个类是一个抽象类
   // abstract修饰方法，这个方法就是一个抽象方法，抽象方法没有方法体
   public abstract void eat();
   
}

1. 抽象类不可以创建对象

2. 抽象类的子类，必须重写父类的抽象方法

通过抽象类可以强制地要求子类中必须有哪些方法。

注：抽象类中可以有正常的方法。

9.接口

接口实际上是一种特殊的抽象类。

接口中所有的方法都是抽象方法。

接口中所有变量都是全局静态变量（public static final）。

接口使用 interface 来声明。

// 能继承接口的只能是接口

// 接口和类只能是实现关系 implements

public interface Valuable {

        // 接口中所有的方法都是抽象方法，可以省略掉abstract

        //接口中所有内容都是公开的，公共的

        void getMoney() ;               // 接口中所有的方法都是抽象方法，不可以有正常方法     

}

// Valuable.java
public interface Valuable {
    void getMoney();
}



// Gold.java
public class Gold implements Valuable {
    // 必须 实现 抽象方法
    public void getMoney(){
        System.out.println("实现");
    }
}




// Test.java
public class Test {
    public static void main(String[] args) {
        Gold g = new Gold();
        g.getMoney();
    }
}

1. 类只能单继承，接口支持多实现。即类只能继承一个类，但可以实现多个接口。

2. 接口同样具有多态性。

3. 接口可以把很多不相关的内容整合。

快捷方式：

右键 -> generate -> override -> 选中要重写的方法

10. 成员变量初始化

待补充……