java基础核心总结

访问修饰符

public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用

private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用

protected表示在用一个包了，相当于public ，不在同一个相当于private。特点：不同的包，子类可以继承该属性方法。

default 表示在用一个包了，相当于public ，不在同一个相当于private。特点：不同的包，子类无法继承该属性方法。

构造函数与方法重载（Overload）

对象可以创建多个构造函数，只要参数类型或者个数不同，称为重载构造函数（Overload）

重写（override）

参数类型和个数相同，成为重载函数

继承与多态

继承（extends）

private成员可以继承 但是无法外部访问且子类无法直接存取，必须提供父类方法获取。

只能继承一个，不能多继承

多态

方法重载是多态的一种形式

向上转型 （Cat 继承于 Animal）

Animal a = new Cat();

a.eat(); //调用的Cat的 如果父类（Animal）没有这个eat方法直接报错

向下转型

Cat c = （Cat）a； // 前提是 a 是Cat对象（实际上的对象，不是Animal引用对象）

c.eat(); //调用的Cat的

c.work(); //调用Cat的 父类Animal是没有的

？ Cat t = new Animal(); // cat 不能创建 Animal对象 错误的

 

抽象类（abstract）

抽象类不能被实例化，只要抽象类的非抽象类的子类可以创建对象

抽象类不一定包含抽象方法，但有抽象方法的一定是抽象类

抽象类的抽象方法只是声明，没有方法的具体实现

构造方法，类方法，static修饰的方法，不能声明为抽象方法

抽象类的子类必须实现抽象类中抽象方法，除非子类是抽象类

接口 (implements)

接口不能实例化对象

接口没有构造方法

接口所有的方法必须是抽象方法 //重点

接口不能包含成员变量，除了static 和 final 的变量

可以实现多个接口，接口可以继承多个接口

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。

接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。

接口中的方法都是公有的。

内部类

成员内部类

class Circle {
 private double radius = 0;
 public static int count =1;
 public Circle(double radius) {
     this.radius = radius;
 }
​
 class Draw {     //内部类
     public void drawSahpe() {
         System.out.println(radius);  //外部类的private成员
         System.out.println(count);   //外部类的静态成员
     }
 }
}
结果：  0  1

 

类Draw像是类Circle的一个成员，Circle称为外部类。

成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.变量/方法

外部类访问内部类需要创建内部类对象，通过对象访问内部类的成员变量和方法

成员内部类创建对象：

Circle c = new Circle();
Circle.Draw d = c.new Draw();
d.drawSahpe();

 

局部内部类

局部内部类就像是方法里面的一个局部变量一样，但是不能有 public、protected、private 以及 static 修饰符的

匿名内部类

history_bt.setOnClickListener(new OnClickListener() {
​
 @Override
 public void onClick(View v) {
​
 }
});

匿名内部类写发如下

new OnClickListener() {
 @Override
 public void onClick(View v) {
​
 }
}

匿名内部类没有名字没有构造函数 只有 { 方法 }

静态内部类

class Outter {
public Outter() {
​
}
​
static class Inner {    //静态内部类
   public Inner() {
      System.out.println("这是静态内部类");
   }
}
}

静态内部类无法访问外部非static 变量和方法

静态内部类对象创建：

Outter.Inner a = new Outter.Innter();
a.Inner(); 

线程

Java 提供了三种创建线程的方法

• 通过实现 Runnable 接口；

• 通过继承 Thread 类本身；

• 通过 Callable 和 Future 创建线程。

Thread线程创建

public class ThreadDemo extends Thread {
   String threadName;
​
   public ThreadDemo(String runName)
   {
       this.threadName = runName;
       System.out.println("创建线程:" + runName);
   }
​
   public void run() {
​
       System.out.println("开始线程: " + threadName);
​
       for(int i = 0;  i < 5; i++)
       {
           System.out.println(threadName + "  进行第" + i + "运行----");
​
           try {
               Thread.sleep(0);            //睡眠时间
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
}

public static void main(String [] args)
    {
        ThreadDemo r1 = new ThreadDemo("线程1");
        ThreadDemo r2 = new ThreadDemo("线程2");
​
        Thread r1thread = new Thread(r1);
        r1thread.start();
        Thread r2thread = new Thread(r2);
        r2thread.start();
    }

 结果：