Java Class09
访问修饰符
访问修饰符对类中的成员做了限制，分出了分类等级，让哪些成员可以在哪些级别下可以访问
private：私有
default：默认
protected：受保护
public：公共
static
成员变量分为两种，dynamic（动态的）和static（静态的），在代码中默认的就是动态类型，而使用static需要在变量和方法前添加用来说明
dynamic是调用才生成，但static在类生成的时候就跟着一起被调用，直到全部执行完被当做垃圾清空时才停止使用（与类同生共死）
public class Test {
public static int number=100;//定义静态属性
static{
//定义静态初始化块
System.out.println("number的值为:");
}
public static int result(){
//定义静态方法
System.out.println(number+100);
return number;
}
public static void main(String[] args) {
Test test=new Test();//实例化对象
//自动调用静态初始化块
System.out.println(test.number);//直接输出静态属性的值
result();//不使用对象直接调用方法
}
}
static可以修饰属性，方法，初始化块
public class C extends C0{
public C(){
super(100);
System.out.println(1);
}
{
System.out.println(2);
}
static{
System.out.println(3);
}
public C(int age){
this();
System.out.println(8);
}
public static void main(String[] args) {
new C(100);
}
}
class C0{
public C0(){
System.out.println(6);
}
public C0(int age){
this();
System.out.println(7);
}
static{
System.out.println(5);
}
{
System.out.println(4);
}
}
调用先后顺序及底层逻辑
调用顺序：静态代码块>调用的静态方法>继承>代码块>调用方法顺序
Final关键字
final意为不可改变的，最终的。final关键字可以修饰类，属性，方法
被final修饰的成员不可被覆盖，例如final类不可做父类（相当于太监类）
final可以用来修饰全局变量（全局不可更改）
public static final int i=100;
全局的 直接可以使用的 不可修改的 类型变量的值
Abstract与Interface
两者有很多共同点与不同点
Abstract
抽象类，在内部有一些抽象方法（有抽象方法的类就是抽象类）
public abstract class Father {
public void gotoSchool(){
//定义成员方法
System.out.println("去上学");
}
}
public class Son extends Father{
@Override
public void gotoCollege() {
System.out.println("去上大学");
}
public static void main(String[] args) {
Son son=new Son();
son.gotoSchool();
son.gotoCollege();
}
}
父类中含有可实现方法gotoSchool，也有抽象方法gotoCollege，子类继承父类，直接就可以使用gotoSchool方法，但对于gotoCollege方法只有两个选择：实现和不实现。
如果实现就如代码写的那样，在调用时正常使用；
如果不实现则则必须要转成抽象类，交给其能实现的子类
想在父类中直接实例化是不可以的，因为抽象类不可实例化。如果非要使用则使用下节内容的内部类实现的方式去解决
Interface
接口是比抽象类更抽象的，它在内部只允许有抽象的方法，接口是为了解决java中不能实现多继承而实现的
public interface A {
public void method();
}
public interface A1 {
public void method1();
}
public class B implements A,A1 {
@Override
public void method() {
System.out.println("生成解决方案");
}
@Override
public void method1() {
System.out.println("输出解决方案");
}
public static void main(String[] args) {
B b = new B();
b.method();
b.method1();
}
}
abstract和interface的区别
1.方法实现：
abstract中抽象方法和普通方法都可以有，但interface只允许抽象方法
2.属性使用：
abstract中的访问控制符无限制，但interface只能是public
3.静态方法：
abstract中可以有静态方法，但interface不能有
4.静态代码块：
abstract中可以有静态代码块，但interface不能有
5.多继承：
abstract是但继承，但interface是多继承
多态
多态是在继承的基础上产生的，子类继承父类时重写父类的方法，这种在同一方法中不同子类表现出的不同形式就是多态。
多态分为编译时多态和运行时多态
编译时多态：方法的重载
public class A {
private int age;
private String name;
public void method(int age){
System.out.println(age);
}
public void method(int age,String name){
System.out.println(age+name);
}
}
运行时多态：方法的重写
public class A {
private int age;
private String name;
public void method(int age){
System.out.println(age);
}
public void method2(int age,String name){
System.out.println(age+name);
}
}
class B extends A{
@Override
public void method(int age){
System.out.println(age+10);
}
}
instanceof运算符
变量 instanceof 类
意为判断这个变量是否属于这个类中，是的话返回true，否则返回false
public class Son extends Father{
public static void main(String[] args) {
GrandPa g=new Father();
Father f= new Son();
GrandPa g1=new Uncle();
System.out.println(g instanceof Father);//true
System.out.println(f instanceof Son);//true
System.out.println(g1 instanceof Uncle);//true
}
}
class Uncle extends GrandPa{
}
class Father extends GrandPa{
}
class GrandPa{
}