JAVA零基础小白学习教程之day09-内部类&权限&final&静态

1. 【理解】什么是内部类
2. 【掌握】匿名内部类
3. 【掌握】引用数据类型作为方法的参数
4. 【理解】final关键字的使用
5. 【理解】包的定义及使用
6. 【理解】权限修饰符
7. 【掌握】static关键字的使用

class 外部类 {
    成员变量
    成员方法
    class 成员内部类{ 
    }
}

外部类名.内部类名 对象名 = new 外部类型().new 内部类型();

public class Person {
    private boolean live;
    //内部类
    class Heart{
        public void jump(){            
            //内部类可以直接访问外部类的成员，包括私有
            if (live){
                System.out.println("在跳");
            }else{
                System.out.println("不在跳");
            }
        }
    }
    public void setLive(boolean live) {
        this.live = live;
    }
}

public class InnerDemo {
    public static void main(String[] args) {       
        //创建外部类对象
        Person p = new Person();
        p.setLive(true);
        //创建内部类对象
        Person.Heart heart = p.new Heart();
        //调用内部类方法
        heart.jump();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}
public class Outer {
    public void show(){
        // 局部内部类
        class Inner{
            public void method(){
                System.out.println("Inner 局部内部类的method方法执行了....");
            }
        }
        // 在外部类的方法内使用局部内部类
        Inner inner = new Inner();
        inner.method();
    }
}

1. 定义实现类 
2. 重写接口中的方法 
3. 创建实现类 对象 
4. 调用重写后的方法

new 父类名或者接口名(){
    // 方法重写
    @Override 
    public void method() {        // 执行语句
    }
};

public interface FlyAble{
    public abstract void fly();
}

public class InnerDemo {
    public static void main(String[] args) {
   		//直接new接口，无需写实现类来实现接口
        new FlyAble(){
           //直接实现方法
            public void fly() {
                System.out.println("我飞了~~~");
            }
        }.fly();
    }
}

public class InnerDemo2 {
    public static void main(String[] args) {
        FlyAble f = new FlyAble(){
            //直接重写抽象方法
            public void fly(){
                System.out.println("我要飞，飞啊，飞，，");
            }
            @Override
            public void fly2() {
                System.out.println("我要飞，飞啊，飞，，2222");
            }
        };
        f.fly();
        f.fly2();
    }
}

public class InnerDemo3 {
    public static void main(String[] args) {
        showFly(new FlyAble() {
            @Override
            public void fly() {
                System.out.println("9999999");
            }
            @Override
            public void fly2() {
                System.out.println("888888888");
            }
        });
    }
    public static void showFly(FlyAble f){
        f.fly();
        f.fly2();
    }
}

普通类-作为方法的形参

方法的形参是类名，其实需要的是该类的对象
实际传递的是该对象的【地址值】

public class Student {
    public void study(){
        System.out.println("好好学习，天天向上");
    }
}
public class StudentDemo {
    //把普通类当作一个参数
    public void method(Student student){
        student.study();
    }
}
public class StudentTest {
    public static void main(String[] args) {
        StudentDemo st = new StudentDemo();
        Student s = new Student();
        st.method(s);
    }
}

普能类-作为方法的返回值
  
  方法的返回值是类名，其实返回的是该类的对象
  实际传递的，也是该对象的【地址值】

public class Student {
    public void study(){
        System.out.println("好好学习，天天向上");
    }
}
public class StudentDemo {
    //返回值类型为一个类
    public Student getStudent(){
        return  new Student();
    }
}
public class StudentTest {
    public static void main(String[] args) {
        StudentDemo st = new StudentDemo();
        //返回也是一个对象
        Student student = st.getStudent();
        student.study();
    }
}

public abstract class Person {
    public abstract void study();
}
public class PersonDemo {
    public void method(Person p){
        p.study();
    }
}
//抽象类作为参数，必须实例化
public class Student extends Person {
    @Override
    public void study() {
        System.out.println("好好学习，天天向上！！");
    }
}
//测试
public class PersonTest {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo();

        //抽象类需要一个具体类来实现
        Person p = new Student();
        //method的参数是一个抽象类，那抽象类如何实例化呢? 多态的方式
        pd.method(p);
    }
}

public abstract class Person {
    public abstract void study();
}
public class PersonDemo {
    //返回对象是一个抽象类
    public Person getPerson(){
        //person是一个抽象类，只能通过多态的方法实例化
        // Person p = new Student();
        // return p;
        return new Student();
    }
}
//具体子类实现抽象类Person
public class Student extends Person {
    @Override
    public void study() {
        System.out.println("好好学习，天天向上！！");
    }
}
//测试
public class PersonTest {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo();

        Person person = pd.getPerson();
        person.study();
    }
}

public interface Love {
    public abstract void show();
}
public class LoveDemo {
    //接口作为参数
    public void method(Love love){
        love.show();
    }
}
//子类实现接口
public class LoveImpl implements Love {
    @Override
    public void show() {
        System.out.println("爱一燕");
    }
}
//测试
public class LoveTest {
    public static void main(String[] args) {
        LoveDemo ld = new LoveDemo();
        //需要对接口的参数进行实现化，多态的方法
        Love love = new LoveImpl();
        //参数需要的是一个接口
        ld.method(love);
    }
}

public interface Love {
    public abstract void show();
}
public class LoveDemo {
    //接口作为返回值
    public Love getLove(){
        // 接口不能直接返回，需要实例化，多态的方式
        // Love love = new LoveImpl();
        // return love;
        return new LoveImpl();
    }
}
//子类实现接口
public class LoveImpl implements Love {
    @Override
    public void show() {
        System.out.println("爱一燕");
    }
}
//测试
public class LoveTest {
    public static void main(String[] args) {
        LoveDemo ld = new LoveDemo();

        Love love = ld.getLove();
        love.show();
    }
}

> 查询API发现像 public final class String 、 public final class Math 、 public final class Scanner 等，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容

### 3.3.2修饰方法

```java
public  class Fu {
  public final void show(){
      System.out.println("fu..show..");
  }
}
public class Zi extends Fu {
  //子类继承父类中的final修饰的方法
  public void show(){
      System.out.println("fu..show..");
  }
}

public  class Fu {
    final int num = 10;
    public  void show(){
        System.out.println("fu..show..");
    }
}
public class Test {
    public static void main(String[] args) {
        Fu f = new Fu();
        System.out.println(f.num);//10
        // f.num = 20;  final修饰的变量，变成常量，不能进行修改
    }
}

package cn.yanqi.soft1;
/**
 * @Auther: yanqi
 */
public class Father {
    public void publicShow1(){
        System.out.println("father-public-show1 ");
    }
    private void privateShow2(){
        System.out.println("father-private-show2 ");
    }
    protected void protectedShow3(){
        System.out.println("father-protected-show3 ");
    }
    void show4(){
        System.out.println("father-默认修改-show4");
    }
    public static void main(String[] args) {
        Father f = new Father();
        f.publicShow1();
        f.privateShow2();
        f.protectedShow3();
        f.show4();
    }
}

package cn.yanqi.soft1;

/**
 * @Auther: yanqi
 * @Desc  同一包下子类，可以访问除私有以外的所有方法
 */
public class Son extends Father {
    public static void main(String[] args) {
        Father f = new Father();
        f.publicShow1();
        f.protectedShow3();
        f.show4();

        Son s = new Son();
        s.publicShow1();
        s.protectedShow3();
        s.show4();
    }
}

package cn.yanqi.soft1;

/**
 * @Auther: yanqi
 * @Desc 同一包无关类，可以访问除私有以外的所有方法
 */
public class Test {
    public static void main(String[] args) {
        Father f = new Father();
        f.publicShow1();
        f.protectedShow3();
        f.show4();
    }
}

package cn.yanqi.soft2;
import cn.yanqi.soft1.Father;
/**
 * @Auther: yanqi
 * @Desc  不同包子类，只能访问 public protected
 */
public class Son2 extends Father {
    public static void main(String[] args) {
        Son2 s = new Son2();
        s.publicShow1();
        s.protectedShow3();        
    }
}

package cn.yanqi.soft2;
import cn.yanqi.soft1.Father;
/**
 * @Auther: yanqi
 * @Date: 11:29
 * @Desc  不同包下的无关类，只能访问 pubLic
 */
public class Test2 {
    public static void main(String[] args) {
        Father f = new Father();
        f.publicShow1();
    }
}

static的特点：(它可以修饰成员变量，还可以修饰成员方法)
		A:随着类的加载而加载
			回想main方法。
		B:优先于对象存在
		C:被类的所有对象共享
			举例：咱们班级的学生应该共用同一个班级编号。
			其实这个特点也是在告诉我们什么时候使用静态?
				如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
			举例：
				饮水机(用静态修饰)
				水杯(不能用静态修饰)
		D:可以通过类名调用
			其实它本身也可以通过对象名调用。
			推荐使用类名调用。
			
			静态修饰的内容一般我们称其为：与类相关的，类成员

public class Student {
    //非静态变量
    int num1 = 10;
    //静态变量
    static int num2 = 20;
}
public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();

        System.out.println(s.num1);
        System.out.println(s.num2);//也可以用对象来调用静态变量，不推荐

        //可以直接用类名直接调用静态变量
        System.out.println(Student.num2);
    }
}

static关键字注意事项
		A:在静态方法中是没有this关键字的
			如何理解呢?
				静态是随着类的加载而加载，this是随着对象的创建而存在。
				静态比对象先存在。
		B:静态方法只能访问静态的成员变量和静态的成员方法
				静态方法：
					成员变量：只能访问静态变量
					成员方法：只能访问静态成员方法
				非静态方法：
					成员变量：可以是静态的，也可以是非静态的
					成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
			简单记：
				静态只能访问静态。非静态可以访问静态也可以访问非静态

public class Student {
    //非静态变量
    int num1 = 10;
    //静态变量
    static int num2 = 20;

    //非静态方法
    public void show(){
        System.out.println(num1);
        System.out.println(this.num1);
        System.out.println(num2);

        //方法：非静态的可以访问静态的也可以访问非静态的
        function();
        function2();
    }
    //静态方法
    public static void method(){
        //静态不能访问非静态的成员变量
        // System.out.println(num1);

        //静态中没有this
        // System.out.println(this.num1);

        //静态方法可以访问静态的成员变量
        System.out.println(num2);

        //静态不能访问非静态的
        // function();

        //静态可以访问静态的
        function2();
    }


    public void function(){
        System.out.println("function");
    }

    public static void function2(){
        System.out.println("function2");
    }
}

// 访问类变量 
类名.类变量名；    
// 调用静态方法 
类名.静态方法名(参数)；

所属不同
	静态成员变量属于类，所以也称为类变量
	成员变量属于对象，所以也称之为实例变量(对象变量)
内存中位置不同
	静态变量存储于方法区的静态区
	成员变量存储于堆内存中
内存出现的时间不同
	静态变量随着类的加载而加载，随着类的消失而消失
	成员变量随着对象的创建而创建，随着对象的消失而消失
调用不同
	静态变量可以通过类名调用，也可以通过对象来调用
	成员变量只能通过对象名调用

public class ClassName{ 
   static {
       // 执行语句 
   }
}

public class Game {
    static int age;
    static String name;
    static {
        age = 27;
        name = "江一燕";
        System.out.println(name+": "+age);
    }
}

public class GameTest {
    public static void main(String[] args) {
        Game g = new Game();
        Game g2 = new Game();
    }
}

所属不同
	静态成员变量属于类，所以也称为类变量
	成员变量属于对象，所以也称之为实例变量(对象变量)
内存中位置不同
	静态变量存储于方法区的静态区
	成员变量存储于堆内存中
内存出现的时间不同
	静态变量随着类的加载而加载，随着类的消失而消失
	成员变量随着对象的创建而创建，随着对象的消失而消失
调用不同
	静态变量可以通过类名调用，也可以通过对象来调用
	成员变量只能通过对象名调用

public class ClassName{ 
   static {
       // 执行语句 
   }
}

public class Game {
    static int age;
    static String name;
    static {
        age = 27;
        name = "江一燕";
        System.out.println(name+": "+age);
    }
}

public class GameTest {
    public static void main(String[] args) {
        Game g = new Game();
        Game g2 = new Game();
    }
}