zsfafa.com

            
		public class ATeacher extends Teacher{
    	@Override
    	public void work() {

    	}
		}
		
        

            
		public abstract class Person {

		private String name;
		private int age;

		//作用：当创建子类对象的时，给属性进行赋值的。
		public Person() {
		}

		public Person(String name, int age) {
			this.name = name;
			this.age = age;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public int getAge() {
			return age;
		}

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

		public abstract void work();

		public void sleep(){
			System.out.println("睡觉");
		}
		}
		
        

            
		public class Student extends Person{


		public Student() {
		}

		public Student(String name, int age) {
			super(name, age);
		}

		@Override
		public void work() {
			System.out.println("学生的工作是学习");
		}
		}
		
        

            
		public abstract class Teacher extends Person{
		}
		
        

            
		public class Test {
    	public static void main(String[] args) {
        //创建对象
        //Person p = new Person();


        Student s = new Student("zhangsan",23);

        System.out.println(s.getName() + ", " + s.getAge());
    	}
		}
		
        

            
		public abstract class Animal {
		private String name;
		private int age;

		public Animal() {
		}

		public Animal(String name, int age) {
			this.name = name;
			this.age = age;
		}


		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public int getAge() {
			return age;
		}

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

		public void drink(){
			System.out.println("动物在喝水");
		}

		public abstract void eat();
		}
		
        

            
		public class Dog extends Animal{


		public Dog() {
		}

		public Dog(String name, int age) {
			super(name, age);
		}

		@Override
		public void eat() {
			System.out.println("狗吃骨头");
		}
		}
		
        

            
		public class Frog extends Animal{

		public Frog() {
		}

		public Frog(String name, int age) {
			super(name, age);
		}

		@Override
		public void eat() {
			System.out.println("青蛙在吃虫子");
		}
		}
		
        

            
		public class Sheep extends Animal{

		public Sheep() {
		}

		public Sheep(String name, int age) {
			super(name, age);
		}

		@Override
		public void eat() {
			System.out.println("山羊在吃草");
		}
		}
		
        

            
		public class Test {
    	public static void main(String[] args) {
        //创建对象



        Frog f = new Frog("小绿",1);
        System.out.println(f.getName() + ", " + f.getAge());
        f.drink();
        f.eat();
    	}
  		}
		
        

            
		public class Car {
		String carName;
		int carAge;
		String carColor;


		public void show(Car this){
			//是打印调用者车的名字：宾利
			System.out.println(this.carName);
			Engine e = new Engine();
			System.out.println(e.engineName);
		}


		class Engine{
			String engineName;
			int engineAge;

			public void show(){
				System.out.println(engineName);
				System.out.println(carName);
			}
		}
		}
		
        

            
		public class Test {
    	public static void main(String[] args) {
        /*
            需求：写一个Javabean类描述汽车。
            属性：汽车的品牌，车龄，颜色，发动机的品牌，使用年限。

            内部类的访问特点:
                内部类可以直接访问外部类的成员，包括私有
                外部类要访问内部类的成员，必须创建对象

        */

        Car c = new Car();
        c.carName = "宾利";
        c.carAge = 1;
        c.carColor = "粉色";

        c.show();
    	}
		}
		
        

            
		public class Outer {
		String name;

		private class Inner{
			static int a = 10;
		}


		public Inner getInstance(){
			return new Inner();
		}


		}
			
        

            
		public class Test {
    	public static void main(String[] args) {
       /*
        编写成员内部类的注意点：
            1.成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等
            2.在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。

        获取成员内部类对象的两种方式：
            方式一：外部类编写方法，对外提供内部类对象（private）

            方式二：直接创建
            格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
            范例：Outer.Inner oi = new Outer().new Inner();
        */


        //创建对象的方式：
        //类名 对象名 = new 类名（）；
        //Student s = new Student();

        //我要创建的是谁的对象？
        //内部类的对象

       // Outer.Inner oi = new Outer().new Inner();

        Outer o = new Outer();
        System.out.println(o.getInstance());


    	}
		}
		
        

            
		public class Outer {
    	private int a = 10;

    	class Inner {
        private int a = 20;

        public void show() {
            int a = 30;
            //Outer.this 获取了外部类对象的地址值
            System.out.println(Outer.this.a);//10
            System.out.println(this.a); //20
            System.out.println(a); //30
        }
    	}
		}
		
        

            
		import java.util.Scanner;

		public class Test {
    	public static void main(String[] args) {
        //创建内部类的对象，并调用show方法
        Outer.Inner oi = new Outer().new Inner();

        oi.show();


        Scanner sc = new Scanner(System.in);
        sc.next();
    	}
		}
		
        

            
		public class Outer {

		//int a = 10;
		//static int b = 20;

		//静态内部类
		static class Inner {
			public void show1(){
				System.out.println("非静态的方法被调用了");
			}

			public static void show2(){
				System.out.println("静态的方法被调用了");
			}
		}
		}
		
        

            
		public class Test {
    	public static void main(String[] args) {
        //注意事项：
        //1.静态内部类也是成员内部类中的一种
        //2.静态内部类只能访问外部类中的静态变量和静态方法，
        //  如果想要访问非静态的需要创建外部类的对象。

        //创建静态内部类对象的格式：
        //      外部类名.内部类名 对象名 = new 外部类名.内部类名();
        //调用静态方法的格式：
        //      外部类名.内部类名.方法名();


        //创建静态内部类的对象
        //只要是静态的东西，都可以用类名点直接获取
        Outer.Inner oi = new Outer.Inner();
        oi.show1();

        //静态方法
        Outer.Inner.show2();

    	}
		}
		
        

            
		public class Outer {

    	int b = 20;

    	public void show(){
        int a = 10;

        //局部内部类
        class Inner{
            String name;
            int age;

            public void method1(){
                System.out.println(a);
                System.out.println(b);
                System.out.println("局部内部类中的method1方法");
            }

            public static void method2(){
                System.out.println("局部内部类中的method2静态方法");
            }
        }

        //创建局部内部类的对象
        Inner i = new Inner();
        System.out.println(i.name);
        System.out.println(i.age);
        i.method1();
        Inner.method2();
    	}
		}
		
        

            
		public class Test {
    	public static void main(String[] args) {
        /*
        局部内部类
        1.将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量。
        2.外界是无法直接使用局部内部类，需要在方法内部创建对象并使用。
        3.该类可以直接访问外部类的成员，也可以访问方法内的局部变量。*/


        //调用show方法，让代码执行
        Outer o = new Outer();
        o.show();

    	}
		}
		
        

            
		public abstract class Animal {
    	public abstract void eat();
		}
		
        

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

            
		public interface Swim {
    	public abstract void swim();
		}
		
        

            
		public class Test {

    	public static void main(String[] args) {
       /*
            需要大家理解匿名内部类的格式，而不是硬记：
                new 类名或者接口名() {
                 重写方法;
                };
        */

        //编写匿名内部类的代码
        new Swim(){
            @Override
            public void swim() {
                System.out.println("重写了游泳的方法");
            }
        };


        new Animal(){
            @Override
            public void eat() {
                System.out.println("重写了eat方法");
            }
        };

        //在测试类中调用下面的method方法？
        //以前的方式如何调用？
        //要自己写一个子类继承Animal类
        //再创建子类的对象，传递给method方法
       /* Dog d = new Dog();
        method(d);*/
        //如果Dog类我只要用一次，那么还需要单独定义一个类太麻烦了。

        method(

                new Animal() {
                    @Override
                    public void eat() {
                        System.out.println("狗吃骨头");
                    }
                }

        );
    	}
		public static void method(Animal a){//Animal a = 子类对象 多态
			a.eat();//编译看左边，运行看右边
		}
		}
		
        

            
		public class Test2 {

    	//是一个没有名字的成员内部类
    	Swim s = new Swim(){

        @Override
        public void swim() {
            System.out.println("重写之后游泳方法");
        }
		};



		public static void main(String[] args) {
			//回顾一下匿名内部类的格式
			/*
			*
			*           new 类/接口(){
			*               重写的方法;
			*           }
			*
			*
			* */

			//整体我们可以理解为Swim接口的实现类对象
			//接口多态
			Swim s = new Swim(){

				@Override
				public void swim() {
					System.out.println("重写之后游泳方法");
				}
			};

			//编译看左边，运行看右边的原则
			s.swim();

			new Swim(){

				@Override
				public void swim() {
					System.out.println("重写之后游泳方法");
				}
			}.swim();

		}
		}
		
        

            
		public abstract class Animal {
		private String name;
		private int age;


		public Animal() {
		}

		public Animal(String name, int age) {
			this.name = name;
			this.age = age;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public int getAge() {
			return age;
		}

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


		public abstract void eat();

		}
		
        

            
		public class Dog extends Animal implements Swim{

		public Dog() {
		}

		public Dog(String name, int age) {
			super(name, age);
		}

		@Override
		public void eat() {
			System.out.println("狗吃骨头");
		}

		@Override
		public void swim() {
			System.out.println("狗刨");
		}
		}
		
        

            
		public class Frog extends Animal implements Swim{

		public Frog() {
		}

		public Frog(String name, int age) {
			super(name, age);
		}

		@Override
		public void eat() {
			System.out.println("青蛙在吃虫子");
		}

		@Override
		public void swim() {
			System.out.println("青蛙在蛙泳");
		}
		}
		
        

            
		public class Rabbit extends Animal{


		public Rabbit() {
		}

		public Rabbit(String name, int age) {
			super(name, age);
		}

		@Override
		public void eat() {
			System.out.println("兔子在吃胡萝卜");
		}
		}
		
        

            
		public interface Swim {

    	public abstract void swim();

		}
		
        

            
		public class Test {

    	public static void main(String[] args) {
       //创建青蛙的对象
       Frog f = new Frog("小青",1);
        System.out.println(f.getName() + ", " + f.getAge());

        f.eat();
        f.swim();

        //创建兔子的对象
        Rabbit r = new Rabbit("小白",2);
        System.out.println(r.getName() + ", " + r.getAge());
        r.eat();
    	}
		}
		
        

            
		public interface Inter {
		//public static final
		int a = 10;

		//public abstract
		void method();
		}
		
        

            
		public class InterImpl implements Inter{
		@Override
		public void method() {
			System.out.println("method");
		}
		}
		
        

            
		import java.util.Scanner;

		/*
			成员变量
				只能是常量，默认修饰符：public static final
			构造方法
				没有
			成员方法
				只能是抽象方法，默认修饰符：public abstract
		*/
		public class Test {
			public static void main(String[] args) {

        //创建实现类对象并调用方法
        InterImpl ii = new InterImpl();
        ii.method();


        Scanner sc = new Scanner(System.in);
        sc.next();

    	}
		}
		
        

            
		public interface Inter1 {
		public abstract void method1();
		public abstract void method2();
		public abstract void method3();
		}
		
        

            
		public interface Inter2 {
		public abstract void method1();
		public abstract void method2();
		public abstract void method3();
		public abstract void method4();
		}	
		
        

            
		public class InterImpl implements Inter1,Inter2{

		@Override
		public void method1() {
			System.out.println("method1");
		}

		@Override
		public void method2() {
			System.out.println("method2");
		}

		@Override
		public void method3() {
			System.out.println("method3");
		}

		@Override
		public void method4() {
			System.out.println("method4");
		}
		}
		
        

            
		public class Test {
		public static void main(String[] args) {
		// 类和接口之间的关系：
		//      实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
    	}
		}
		
        

            
		public interface Inter1 {
    	public abstract void method1();
		}
		
        

            
		public interface Inter2 {
    	public abstract void method2();
		}
		
        

            
		public interface Inter3 extends Inter1,Inter2{
    	public abstract void method3();
		}
		
        

            
		public class InterImpl implements Inter3{
		@Override
		public void method1() {

		}

		@Override
		public void method2() {

		}

		@Override
		public void method3() {

		}
		}
			
        

            
		public class Test {
    	public static void main(String[] args) {
        //接口和接口之间是继承关系，可以单继承，也可以多继承
        //细节：如果实现类实现了最下面的子接口，那么就需要重写所有的抽象方法
   		 }
		}
		
        

            
		public class BasketballCoach extends Coach{

		public BasketballCoach() {
		}

		public BasketballCoach(String name, int age) {
			super(name, age);
		}

		@Override
		public void teach() {
			System.out.println("篮球教练正在教如何打篮球");
		}
		}
		
        

            
		public class BasketballSporter extends Sporter{

		public BasketballSporter() {
		}

		public BasketballSporter(String name, int age) {
			super(name, age);
		}

		@Override
		public void study() {
			System.out.println("篮球运动员在学习如何打篮球");
		}
		}
		
        

            
		public abstract class Coach extends Person{

		public Coach() {
		}

		public Coach(String name, int age) {
			super(name, age);
		}

		public abstract void teach();
		}
		
        

            
		public interface English {
    	public abstract void speakEnglish();
		}
		
        

            
		//因为现在我不想让外界去直接创建人的对象
		//因为直接创建顶层父类人的对象此时是没有意义的
		//所以我就把他写为抽象的。
		public abstract class Person {
		private String name;
		private int age;

		public Person() {
		}

		public Person(String name, int age) {
			this.name = name;
			this.age = age;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public int getAge() {
			return age;
		}

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

            
		public class PingPangCoach extends Coach implements English{

		public PingPangCoach() {
		}

		public PingPangCoach(String name, int age) {
			super(name, age);
		}

		@Override
		public void teach() {
			System.out.println("乒乓球教练正在教如何打乒乓球");
		}

		@Override
		public void speakEnglish() {
			System.out.println("乒乓球教练在学习说英语");
		}
		}
		
        

            
		public class PingPangSporter extends Sporter implements English{

		public PingPangSporter() {
		}

		public PingPangSporter(String name, int age) {
			super(name, age);
		}

		@Override
		public void speakEnglish() {
			System.out.println("乒乓球运动员在说英语");
		}

		@Override
		public void study() {
			System.out.println("乒乓球运动员在学习如何打乒乓球");
		}
		}
		
        

            
		public abstract class Sporter extends Person{

		public Sporter() {
		}

		public Sporter(String name, int age) {
			super(name, age);
		}

		public abstract void study();
		}
		
        

            
		public class Test {
    	public static void main(String[] args) {
        //创建运动员或教练的对象

        PingPangSporter pps = new PingPangSporter("刘诗雯",23);
        System.out.println(pps.getName() + ", " + pps.getAge());
        pps.study();
        pps.speakEnglish();

    	}
		}
		
        

            
		public interface InterA {
     		/*接口中默认方法的定义格式：
            格式：public default 返回值类型 方法名(参数列表) {   }

        接口中默认方法的注意事项：
            1.默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字
            2.public可以省略，default不能省略
            3.如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写*/


		public abstract void method();

		public default void show(){
			System.out.println("InterA接口中的默认方法 ---- show");
		}
		}
		
        

            
		public interface InterB {
		public default void show(){
			System.out.println("InterB接口中的默认方法 ---- show");
		}
		}

		
        

            
		public class InterImpl implements InterA,InterB{
		@Override
		public void method() {
			System.out.println("实现类重写的抽象方法");
		}

		@Override
		public void show() {
			System.out.println("重写接口中的默认方法");
		}
		}
		
        

            
		public class Test {
    	public static void main(String[] args) {
        /*接口中默认方法的定义格式：
            格式：public default 返回值类型 方法名(参数列表) {   }

        接口中默认方法的注意事项：
            1.默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字
            2.public可以省略，default不能省略
            3.如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写





            */


        //创建实现类的对象
        //InterImpl ii = new InterImpl();
        //ii.show();
    	}
		}
		
        

            
		public interface Inter {

		public abstract void method();

		public static void show(){
			System.out.println("Inter接口中的静态方法");
		}
		}
		
        

            
		public class InterImpl implements Inter{
		@Override
		public void method() {
			System.out.println("InterImpl重写的抽象方法");
		}

		//不叫重写
		public static void show() {
			System.out.println("InterImpl重写的抽象方法");
		}

		}
		
        

            
		public class Test {
    	public static void main(String[] args) {
        /*
            接口中静态方法的定义格式：
                格式：public static 返回值类型 方法名(参数列表) {   }
                范例：public static void show() {   }

               接口中静态方法的注意事项：
                    静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
                    public可以省略，static不能省略
        */


        //调用接口中的静态方法
        Inter.show();

        //调用实现类中的静态方法
        InterImpl.show();

        //子类把从父类继承下来的虚方法表里面的方法进行覆盖了，这才叫重写。

    	}
		}	
		
        

            
		public interface InterA {

		public static void show1(){
			System.out.println("show1方法开始执行了");
			show4();
		}


		public static void show2(){
			System.out.println("show2方法开始执行了");
			show4();
		}


	   //普通的私有方法，给默认方法服务的
		private void show3(){
			System.out.println("记录程序在运行过程中的各种细节，这里有100行代码");
		}


		//静态的私有方法，给静态方法服务的
		private static void show4(){
			System.out.println("记录程序在运行过程中的各种细节，这里有100行代码");
		}
		}
			
        

            
		public class Test {
    	public static void main(String[] args) {
      /*  接口中私有方法的定义格式：

        格式1：private 返回值类型 方法名(参数列表) {   }
        范例1：private void show() {   }

        格式2：private static 返回值类型 方法名(参数列表) {   }
        范例2：private static void method() {   }
		*/
    	}
		}
		
        

            
		public interface Inter {
		public abstract void method1();
		public abstract void method2();
		public abstract void method3();
		public abstract void method4();
		public abstract void method5();
		public abstract void method6();
		public abstract void method7();
		public abstract void method8();
		public abstract void method9();
		public abstract void method10();
		}
		
        

            
		public abstract class InterAdapter implements Inter{

		@Override
		public void method1() {

		}

		@Override
		public void method2() {

		}

		@Override
		public void method3() {

		}

		@Override
		public void method4() {

		}

		@Override
		public void method5() {

		}

		@Override
		public void method6() {

		}

		@Override
		public void method7() {

		}

		@Override
		public void method8() {

		}

		@Override
		public void method9() {

		}

		@Override
		public void method10() {

		}
		}
		
        

            
		public class InterImpl extends InterAdapter{
	  	//我需要用到那个方法，就重写哪个方法就可以了

		@Override
		public void method5() {
			System.out.println("只要用第五个方法");
		}
		}