Java知识点总结（三个步骤）

Java知识点总结（三个步骤）

@(Java知识点总结)[Java, Java面向对象]

[toc]

1-定义类

修饰符

访问修饰符：

1. public
2. protected
3. default
4. private

其他修饰符

abstract：抽象类不能实例化，专门用于继承的类
final：最终类不能被继承

类名（驼峰命名法）

驼峰标识- 每个单词首字母大写

extends

Java中的继承是单一继承

继承关系中，会调用父类的构造方法来构造子类对象

当父类存在无参构造器时，子类构造器中 Super 关键字，因为它会隐式的调用父类的无参构造器

public Son(){
    //Super();
}

当父类没有无参构造器时，子类需要显示的调用带参构造器，否则编译不通过。

public Son(参数类型 参数名){
    Super(参数名);
    this.参数名 = 参数名;
}

implements

一个类可以实现多个接口来扮演多个角色
多个接口之间用逗号隔开

内部类

内部类：

内部类定义：在一个类的内部在定义一个类

• 内部类可以用多个实例，每个实例都有自己的状态信息，而且与其他外部对象的信息互相独立
• 在单个外部类中，可以让多个内部类已不同的方式实现同一个接口，或者继承同一个类
• 创建内部类对象的时刻并不依赖于外部类对象的创建。
• 内部类并没有令人迷惑的"is-a"关系，他就是一个独立的实体
• 内部类提供更好的封装，除了该外部类，其他类都不能访问

内部类是个编译时的概念，一旦编译成功后，它就与外部类属于两个完全不同的类（当然他们之间还是有联系的）。对于一个名为OuterClass的外围类和一个InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。

成员内部类

成员内部类也是最普通的内部类，它是外部类的一个成员，所以他是可以无限制的访问外围类的所有成员属性和方法，尽管是private 的，但是外围类要访问内部类的成员属性和方法则需要通过内部类的实例去访问

在成员内部类中要注意两个点：

1. 成员内部类中不能存在任何static的变量和方法

2. 成员内部类是依附外部类的，所以只有先创建了外部类才能创建内部类

   public class OuterClass {
   private String name = "张三" ;

   public void outPrint(){

   System.out.println("我是外部类的方法");

   }

   // 内部类
   public class InnerClass{ // 可以声明成public或private

   
   //private static int id;  //成员内部类中不能存在任何static的变量和方法；
   
   public void innerPrint(){
    //可以直接使用外部类的属性和方法
    System.out.println(name+"你好，我是内部类");
    outPrint();
   }
   

   }

   public InnerClass getInnerClass(){

   return new InnerClass();

   }
   public static void main(String[] args) {

   
   //InnerClass innerClass = new InnerClass(); // 不能直接实例化内部类对象
   
   //通过外部类调用内部类
   InnerClass innerClass = new OuterClass().new InnerClass();
   
   OuterClass.InnerClass innerClass2 = new OuterClass().new InnerClass();
   
   //通过get方法来获取内部类（推荐）
   InnerClass innerClass3 = new OuterClass().getInnerClass();
   innerClass3.innerPrint();
   
   /*张三你好，我是内部类
   我是外部类的方法*/
   

   }

   }

局部内部类

局部内部类是嵌套在方法和作用于域的，对于这个类的使用主要是应用与解决比较复杂的问题想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类。

局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效

public class Outer {
  
  private String info = ",我是外部类的属性";
  public void test(final String name){ // 方法中的参数要被内部类访问，必需加上final修饰
    // 定义于方法内的类
    class Inner{
     public void print(){
       System.out.println(name+info); //使用外部类的属性和方法中的参数
     }
    }
    new Inner().print();
  }
 
  public static void main(String[] args) {
    new Outer().test("张三");
    /*张三,我是外部类的属性*/
  }
}

匿名内部类

匿名内部类：创建的对象没有名字

• 匿名内部类是不能加访问修饰符
• 要使用匿名类，这个类是要先定义的
• 当所在的方法的形参需要被内部类里面使用时，该形参必须为final修饰

（内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到自己的内部，外部类的方法修改）

public class Outer2 {
  
  public Inner2 getInner(final String name){
    return new Inner2(){
     private String info = "，我是内部类属性";
 
     @Override
     public void print() {
       System.out.println(name+info);
     }
     
     public void test(){
       System.out.println("我是接口中未定义的方法");
     }
    };
  }
 
  public static void main(String[] args) {
    Inner2 inner2 =new Outer2().getInner("张三");
    inner2.print();
    //inner2.test();  //不能调用接口中未定义的方法
  }
}
 
interface Inner2{
  void print();
}

静态内部类

使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类

静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐式地保存着一个一引用，该引用是指向创建它的外部类，但是静态内部类却没有。没有这个引用就意味着：

• 它的创建不需要依赖外部类

• 它不能使用任何外部类的非static成员变量和方法

  public class Outer3 {
  private String info1 = "我是外部类非静态属性";
  private static String info2 = "我是外部类静态属性";
  private String getInfo1(){

  return "我是外部类非静态方法";

  }
  private static String getInfo2(){

  return "我是外部类静态方法";

  }

  //静态内部类
  public static class Inner3{

  
  public void print(){
   //System.out.println(info1);
   System.out.println(info2);
   System.out.println(getInfo2());
  }

  }

  public static void main(String[] args) {

  new Inner3().print();  //不依赖于外部类，可以直接new 对象
  /*我是外部类静态属性
  我是外部类静态方法*/

  }
  }

内部继承类

public class Test extends Outer4.inner{
 
  //Test 类必须存在外部类作为形参的构造方法，否则编译不通过
  Test(Outer4 out){
    out.super();
  }
}
 
class Outer4 {
  class inner{
    
  }
}

2-创建对象

new

构造器（构造方法）

构造方法定义：

1. 名字跟类名完全一致
2. 没有返回类型
3. 支持重载
4. 可以通过this调用当前类已有其他构造器
5. 隐式构造器：如果一个类没有写任何构造器，编译器就会生成默认无参构造器

3-给对象发送消息