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结果