Java零基础学习（方法参数类型 返回值类型 权限修饰符 内部类 匿名内部类）

• 方法参数类型

  • 类名作为形式参数传递

  如果一个方法的形参要一个类类型的，就传递一个该类的对象
  public class MyTest {
      public static void main(String[] args) {
          Dog dog = new Dog();
          test(dog);					//传递狗类的一个对象
      }
      public static void test(Dog dog){		//需要一个狗类型的形参
          System.out.println("狗可以看门");
      }
  }
  class Dog{
      int age;
      String name;
      public void eat(){
          System.out.println("狗啃骨头");
      }
  }
  

  • 抽象类名作为形式参数传递

  如果一个方法的形参要一个抽象类类型，就传递该抽象类的一个子类对象
  public class MyTest {
      public static void main(String[] args) {
          Dog dog = new Dog();      //也可以用多态的方法，Animal animal=new Dog();
          test(dog);                //传递一个该类的子类对象	test(Animal);
      }
      public static void test(Animal animal){	//形参是动物类，是一个抽象类
          System.out.println("动物可以吃饭");
      }
  }
  abstract class Animal{
      
  }
  class Dog extends Animal{
      int age;
      String name;
      public void eat(){
          System.out.println("狗啃骨头");
      }
  }
  

  • 接口名作为参数传递

  如果一个方法的形参要一个接口类型的，就传递该接口的一个子类对象
  public class MyTest2 {
      public static void main(String[] args) {
          Cat cat = new Cat();
          test(cat);            //传递一个该接口的子类对象
      }
      public static void test(A a){                    //形式参数是一个接口类型
          System.out.println("加菲猫爱吃披萨");
      }
  }
   interface A{
      public abstract void eat();
   }
  class Cat implements A{
      @Override
      public void eat() {
          System.out.println("猫吃鱼");
      }
  }
  

• 方法返回值

  • 类名作为返回值类型

  如果一个方法的返回值类型是一个类，就返回一个该类的对象
  public class MyTest {
      public static void main(String[] args) {
          Dog dog = new Dog();
          test();
      }
      public static Dog test(){
          System.out.println("动物可以吃饭");
          return new Dog();			//返回一个该类的对象
      }
  }
  class Dog{
      int age;
      String name;
      public void eat(){
          System.out.println("狗啃骨头");
      }
  }
  

  • 抽象类名作为返回值类型

  如果一个方法的返回值类型是一个抽象类类型，就返回一个该类的子类对象
  public class MyTest {
      public static void main(String[] args) {
          Dog dog = new Dog();
          test();
      }
      public static Animal test(){
          System.out.println("动物可以吃饭");
          return new Dog();			//返回该类的子类对象
      }
  }
  abstract class Animal{
  
  }
  class Dog extends Animal{
      int age;
      String name;
      public void eat(){
          System.out.println("狗啃骨头");
      }
  }
  

  • 接口名作为返回值类型

  如果一个方法的返回值类型是一个接口名，就返回一个该接口的子类对象
  public class MyTest2 {
      public static void main(String[] args) {
          Cat cat = new Cat();
          test();
      }
      public static A test(){
          System.out.println("加菲猫爱吃披萨");
          return new Cat();
      }
  }
   interface A{
      public abstract void eat();
   }
  class Cat implements A{
      @Override
      public void eat() {
          System.out.println("猫吃鱼");
      }
  }
  

• 链式编程

  当一个方法的返回值类型是类类型，就可以继续打点，调用该对象中的方法
  public class MyTest3 {
      public static void main(String[] args) {
          Student student = new Student();
          Student s1=student.test(100,"阿黄").test(90,"小黑");  //test返回的是Student类，所以可以继续打点
          System.out.println(s1.age);
          System.out.println(s1.name);
      }
  }
  class Student {
      int age;
      String name;
      public Student test(int age,String name){
          this.age=age;
          this.name=name;
          return this;
      }
  }
  

• package关键字的概述及作用

  1.包的概念：就是文件夹
  2.包的作用：用来解决同一路径下不能存在同名文件的问题（分类管理）
  3.包的分类：
  	按照功能
  	按照模块
  

  • 包的定义及注意事项

  1.定义包的格式
  	package 包名;
  	多级包用，分开即可
  2.定义包的注意事项
  	a.package语句必须是程序的第一条可执行代码
  	b.package语句在一个java文件中只能有一个
  	c.如果没有package包，默认表示五包名
  

  • import关键字的概述和使用

  1.导包的概述
  	不同包下的类之间的访问，我们发现每次使用不同包下的类的时候，都需要加包的全路径，比较麻烦。这个时候，Java就提供了导包的功能
  2.导包的格式
  	import 包名;
  	注意：
  		这种方式导入是到类的名称
  		虽然最后可以写*，但是不建议
  3.package，import，class有没有顺序关系
  	package>import>class
  	package只能有一个
  	import可以有多个
  	class可以有多个，但是建议只写一个
  

  • 四种权限修饰符的测试

  1.修饰符
  	private（私有的），默认，protected（保护的），public（公共的）
  2.范围
  				本类	同一包下（子类和无关类）	不同包下（子类）	不同包下（无关类）
  		private		Y
  		默认		Y		Y
  		protected	Y		Y		  Y
  		public		Y		Y		  Y		  Y
  

  • 类及组成所使用的常见修饰符

  1.修饰符
  	权限修饰符：private，默认，protected，public
  	状态修饰符：static，final
  	抽象修饰符：abstract
  2.修饰类的关键字
  	权限修饰符：默认修饰符，public
  	状态修饰符：final
  	抽象类修饰符：abstract
  	
  	用的最多的就是：public
  3.修饰成员变量的关键字
  	权限修饰符：private，默认，protected，public
  	状态修饰符：static，final
  	
  	用的最多的就是：private
  4.修饰构造方法的关键字
  	权限修饰符：private，默认，protected，public
  	
  	用的最多的就是：public
  5.修饰成员方法的关键字
  	权限修饰符：private，默认，protected，public
  	状态修饰符：static，final
  	抽象修饰符：abstract
  	
  	用的最多的就是：public
  6.其他的组合：
  	成员变量：public static final   公共的静态常量
  	成员方法：public static
  			public abstract
  			public final
  

• 内部类分类及成员内部类的直接使用

  1.按照内部位置分类
  	成员位置：在成员位置定义的类
  	局部位置：在局部位置定义的类
  2.成员内部类
  	如何在测试类中直接访问内部类的成员。
  	格式： 外部类名.内部类名 对象名=外部类对象.内部类对象
  

  • 成员内部类的常见修饰符及应用

  1.成员内部类的修饰符
  	private 为了保证数据的安全性
  	static	为了方便数据的访问
  		注意事项：	a.静态内部类访问的外部数据必须用静态修饰
  						public class MyTest4 {
      						static int age;
     							static class Dog{
         							public void b(int a){
             							age=a;
         							}
      						}
  						}
  					b.静态内部类成员方法可以是静态的也可以是非静态的
  2.成员内部类被静态修饰后的访问方式是：
  	格式：外部类名.内部类名 对象名=new 外部类名.内部类名();
  3.私有的内部类，外界无法直接创建其对象
  class Outer {
  	int num = 10;
      //私有的内部类
      private class Inner {
          int a = 20;
  
          public void neiShow() {
              System.out.println(a);
              System.out.println(num);
          }
  
      }
  
      public void waiShow() {
          Inner inner = new Inner();
          inner.neiShow();
      }
  }
  外部类可以通过方法来创建内部类对象，然后外界可以通过外部类对象访问所需要的内部类方法和成员变量。
  

  • 成员内部类的面试题

  1.面试题
  	要求：使用已知的变量，在控制台输出30，20，10。
  	class Outer {
  		public int num = 10;
  		class Inner {
  			public int num = 20;
  			public void show() {
  				int num = 30;
  				System.out.println(num);  
  				System.out.println(num); 
  				System.out.println(num); 
  			}
  		}
  	}
  	class InnerClassTest {
  		public static void main(String[] args) {
  			Outer.Inner oi = new Outer().new Inner();
  			oi.show();
  		}	
  	}
  显然根据就近原则，这三个num都是输出30，要是第二个num输出20可以改成this.num，访问的是本类的对象，
  但是让第三个num输出10，不能用super，因为外部类不是父类，我们就可以创建一个外部类对象，              
  new Outer().num,也可以用一个语法：外部类名.this 表示获取的是外部对象，就可以写Outer.this.num
  

  • 局部内部类访问局部变量的问题

  1.可以直接访问外部类成员，包括私有成员
  2.可以创建内部类对象调用内部类方法，来使用局部内部类功能
  3.局部内部类访问局部变量为什么要用final修饰
  	因为局部变量会随着方法的调用完毕而消失，这时候，局部对象并没有立马从堆内存中消失，因为还要使用那个变量。
  	为了让数据还能继续被使用，就用final修饰，这样。在堆内存里面存储的其实就是一个常量
  4.在外界，无法直接创建局部内部类的对象
  	我们访问时就必须通过创建外部类对象
  	public class MyTest {
      	public static void main(String[] args) {
          	Wai wai = new Wai();
          	wai.show();
      	}
  	}
  	class Wai {
      	private int num = 10;
      	public void show() {
          //定义局部内部类
          	class Nei {
              	int a = 20;
  
              	public void neiShow() {
                  	System.out.println(num);
                  	test();
              	}
          	}
          	Nei nei = new Nei();
          	nei.neiShow();
      	}
      	private void test() {
  
      	}
      	public void hehe() {
          	show();
      	}
  	}
  

  • 匿名内部类

  1.匿名内部类：	就是局部内部类的简化写法。
  2.前提：	存在一个类或者接口，这可类可以是具体类，也可以是抽象类
  3.格式：
  	new 类名或者接口名(){
          重写方法；
  	}；
  4.匿名内部类的本质就是一个继承类该类或者实现了该接口的子类匿名对象
  5.演示
  public class MyTest4 {
      public static void main(String[] args) {
          new Dog(){
              @Override			//抽象类的抽象方法和接口的抽象方法必须重写
              public void run() {
                  System.out.println("狗可以跑步");
              }
  
              public void eat(){
                  System.out.println("狗吃肉");
              }
          };
      }
  }
  abstract class Dog{
      int age;
      String name;
      public void eat(){
          System.out.println("狗吃骨头");
      }
      public abstract void run();
  }
  

  • 匿名内部类的方法调用

  public class MyTest4 {
      public static void main(String[] args) {
          new Dog(){
              @Override
              public void run() {
                  System.out.println("狗可以跑步");
              }
  
              public void eat(){
                  System.out.println("狗吃肉");
              }
          }.eat();		//直接在匿名内部类的后面调用	或者给这个内部类命名再调用
      }
  }
  abstract class Dog{
      int age;
      String name;
      public void eat(){
          System.out.println("狗吃骨头");
      }
      public abstract void run();
  }
  
  

  • 匿名内部类作为参数传递

  A:问题引出
  	首先回顾我们曾经讲过的方法的形式参数是引用类型的情况，
  	我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象，
  	所以，可以使用匿名内部类改进以前的做法。
  B:代码如下
  	//这里写抽象类，接口都行
  	abstract class Person {
  		public abstract void show();
  	}
  	
  	class PersonDemo {
  		public void method(Person p) {
  			p.show();
  		}
  	}
  	
  	class PersonTest {
  		public static void main(String[] args) {
  			//如何调用PersonDemo中的method方法呢?
  			Person a=new Person(){
  				@Override
  				public void show() {
  				}
  			};
  			new PersonDemo(){
  			}.method(a);
  		}
  	}
  

  • 匿名内部类中this关键字

  面试题
  	 interface Inter {
  		public static final int a = 23 ;
  	}
  	
  	public class Test {
  
  		public static void main(String[] args) {
  			new Inter() {
  				public void show() {
  					//this 代表匿名内部类
  					System.out.println(this.a);//23
  		
  				}
  			}.show();
  		}
  	}
  	this代表的是匿名内部类，所以this.a是23
  

  • 匿名内部类的面试题

  按照要求，补齐代码
  	interface Inter { 
  		void show(); 
  	}
  	
  	class Outer { 
  		//补齐代码
          /*
          public static Inter method(){
  			return new Inter(){
  				@Override
  				public void show() {
  					System.out.println("HelloWorld");
  				}
  			};
  		}
          */
  	}
  	
  	class OuterDemo {
  		public static void main(String[] args) {
  			  Outer.method().show();
  		  }
  	}
  	要求在控制台输出”HelloWorld”
  

  总结

  ​ 今天学习了当类名作为形式参数的做法和类名作为返回值的做法，很好理解，但是得多多练习，还有四种权限修饰符的范围，也得记住，如果记不住就可以自己试着演示一下，自己推出来，最后学了内部类和匿名内部类，也要多多练习才能记住