Java基础总结

面向对象技术

Java面向对象的四大特征

抽象：对现实中的某一实体或事件提取相同信息和共同规律的过程

封装：就是将属性或行为隐藏起来，不允许其他人修改，仅对外提供接口。

继承

多态：静态多态和动态多态

访问修饰符

Public：公共的。所有对象都可以调用

Private：私有的。自己内部使用

Protected：受保护的。子类和自己可以使用

Friendly：友好的。同一个包里可以访问。（默认访问修饰符）

方法的重载：同名的方法，参数类型、参数个数、参数的顺序不同的情况。

方法返回类型的不一样不能说明是重载方法。必须依靠方法的名字、参数类型、参数个数、参数顺序

例：下面的两个方法是同种方法，不能称为方法的重载，即使它们的返回类型不同。     public void say(){                   System.out.println("你好啊！");          }     public int say(){                   System.out.println("你好啊！");         return 1;          }

 

构造函数：在类的实例化，或者调用this（）方法的时候自动调用的构造函数。用于对象的创建和初始化

作用：初始化成员变量或者其他的一些数据

特征：构造函数的名称和类名一样

  没有返回值的类型

  可以重载构造函数

当类没有构造函数的时候，类在实例化的时候会自动加上无参的构造函数

值传递和引用传递

值传递：参数传递的是值的副本。方法得到的是保存在形参中的原实参变量的值的副本，对形参变量的操作和修改不会影响到原来实参变量的值。基本数据类型是值传递

public class test1{ public static void main(String args[]){           int tmp=10;                   System.out.println(" 改变前：tmp="+tmp);        change(tmp);           System.out.println(" 改变后：tmp="+tmp); } public static void change(int tmp){           tmp=100; } } class people{          int age; } 结果不变

 

引用传递：参数传递的是值的引用地址，形参和实参引用同一个对象，传递一个指针。对象是引用传递。String本质是引用传递，String的不可修改的特性导致多次赋值时会重建新的String对象，改变的只是地址。

public class test1{ public static void main(String args[]){           people p=new people();           System.out.println(" 改变前：p.age="+p.age);        change(p);           System.out.println(" 改变后：p.age="+p.age); } public static void change(people p){               p.age=100; } } class people{          int age=0; } 结果发生变化，变为100

 

终态

终态类：不能被继承、修改的类，使用final。String 是一个终态类

终态方法：不能被覆盖、修改的方法，使用final

终态属性：不能被修改的属性。final在属性前表示常量。

This关键字：代表类\对象自身

this()调用类自身的构造函数，必须出现在构造函数的第一行。

继承extends

子类继承父类可获取非私有的方法和数据。重复使用共同的方法和属性，简化了代码

Java不支持多继承。

当实例化子类的时候，默认调用父类的无参构造函数。通过super()调用不同的父类（超类、基类）构造方法。super()还可以表示对父类的引用。

例：

public class test{          public static void main(String args[]){              Manager m=new Manager("老板",2000);//调用Manager类的有参构造函数              System.out.println("姓名："+m.EmpName);              System.out.println("薪资："+m.getSalary());              System.out.println("职位："+m.EmpDept);          } } class Manager extends Employee{          protected String EmpDept;          protected int ManagerSalary;                   public Manager(){             this.EmpDept="高级经理";             this.ManagerSalary=1000;          }          public Manager(String EmpDept,int ManagerSalary){             super(2,"李四",2000);//调用父类的有参函数             this.EmpDept=EmpDept;             this.ManagerSalary=ManagerSalary;          }          //当子类中出现和父类中方法名一样的方法，子类的该方法覆盖父类的方法          public int getSalary(){              return EmpSalary+ManagerSalary;          } } class Employee{          protected int EmpId;          protected String EmpName;          protected String EmpSex;          protected String EmpPhone;          protected String EmpAddr;          protected int EmpSalary;            public Employee(){             this.EmpId=1;             this.EmpName="张三";             this.EmpSalary=1000;          }          public Employee(int EmpId,String EmpName,int EmpSalary){             this.EmpId=EmpId;             this.EmpName=EmpName;             this.EmpSalary=EmpSalary;          }          public int getSalary(){             return EmpSalary;          } }

静态方法、静态成员、静态块和普通块。使用static

静态：先于实例化执行的代码，在类的实例化之前就加载静态内容到内存当中。

l  非静态方法可以引用静态方法，但是静态方法不能直接引用非静态方法。

l  静态方法（自定义的）和非静态方法实例化后都可以在任何地方应用其内部方法，
通过“实例化对象类名.方法名”实现。

l  静态方法一般不需实例化，直接通过“类名.方法名”调用。

l  静态成员的赋值是为其最初的空间赋值，若有重赋值则覆盖原来的值。非静态成员则不一样。

静态方法和静态成员通过类名调用。

例：静态方法say、静态字段age public class test2{          public static void main(String args[]){               people.say();               people.age=100;               System.out.println(people.age);          }       } class people{          String name;          static int age;          public static void say(){              System.out.println("非静态的方法");          } }

 

静态变量的引用是不初始化的，直接用最初的声明空间，改变值就是改变最初空间里的值。

非静态变量的引用需要初始化，改变值是改变初始化后的空间的值。

 

静态变量的变量类型可以是一个类。

例：public static TestA a = new TestA();  通过new TestA实例化类TestA，然后将其赋值给类型为TestA的a

 

单独的程序块在构造函数前执行。例{}

静态块的作用：初始化静态变量及其他静态信息。

程序块执行先后顺序：

静态程序块>非静态程序块>构造函数

子类和父类构造函数的执行顺序：

父类的静态块>子类的静态块>父类的非静态块>父类的构造函数>子类的非静态块>子类的构造函数

 

覆盖

原则：方法的返回类型相同；方法的名称相同；方法的参数类型、数量、顺序相同；子类方法修饰符的权限不能比父类更小。

Object里面的equals方法。比较两个对象是否“相等”，比较的是引用地址。

方法的参数里面可以用子类去替换父类（里氏代换原则）

equals是object类的一个方法，比较的是两个对象，即地址。String继承object类，它的equals方法覆盖object的equals方法，比较两个数的值。类似的还有Integer和Double String str=”test”; String str2=”test”; System.out.println(str.equals(str2)); 结果为true。str和str2是两个值，此时equals比较两个值 String str=new String(”test”); String str2=new String(”test”); System.out.println(str==str2); 结果为false。“==”比较两个对象 String str=new String(”test”); String str2=new String(”test”); System.out.println(str.equals(str2)); 结果为true。String的equals方法覆盖object的equals方法，比较两个数的值。 Manager m=new Manager("老板",2000); Manager m2=new Manager("老板",2000); System.out.println(m.equals(m2)); 结果为false。Manager继承object，equals比较两个对象。 总结：对于String这样的类，equals比较的永远是值，==根据条件比较对象或值。       对于其他的没有覆盖object中的equals方法的声明类，equals和==都比较两边的对象。

抽象类和抽象方法

抽象类：只能被继承，不能被实例化，抽象类中可以是抽象方法，也可以是普通方法。

当抽象类被子类继承时，子类必须覆盖父类的抽象方法。

抽象方法：只能是声明，不能被实现，只能出现在抽象类和接口里面。

多态

静态多态：方法重载

动态多态：程序运行时根据对象类型找到对应的方法。

例：

public class test1{          public static void main(String args[]){               Shape s=new sanjiao();//实例化sanjiao后赋给对象shape               System.out.println(s.getShape());          } } abstract class Shape{          String waiguan;          public abstract String getShape();           public void test(){              return "aa";          } } class sanjiao extends Shape{          public String getShape(){              return  "三角形";          } }

异常执行顺序（try语句出现异常）

Finally有return：

catch非return语句—》finally非return语句—》finally return语句：得到finally return结果

finally无return：

catch非return语句—》finally非return语句—》catch return语句：得到catch return结果