java：LeakFilling（面向对象）

1.类的修饰符只能是：public，默认的。另外：final  ,abstract，（修饰符 （只有：public， 默认，）interface+类名 ）。

2.在main函数中创建对象时，new哪个类的个无参构造就是调哪个类的无参构造，同时隐式调用该类父类的无参构造。

　　　　　　　　　　　　　 new有参构造就会调有参构造，同时隐式调用该类父类的无参构造。

3.构造方法和普通方法都可以用四种修饰符来修饰：public，private，protected，默认的。//私有构造方法不能NEW

　抽象方法不能用 private ，final,static修饰

另外：还可以用 static，但是构造方法没有返回值。

父类构造方法和父类私有属性不能被子类继承，但是可以通过super被子类调用。　

　　

eg：

public class Test {
    public static int age;
    protected Test(){
        System.out.println("古道西风瘦马");
    }
    protected Test(int age){
        this.age=age;
        System.out.println("枯藤老树昏鸦");
    }
    public static void main(String[] args) {
        Test t=new Test();
        Test tt=new Test();
        Test2 tt2=new Test2();
        Test2 t2=new Test2(,);
    /*
     * 古道西风瘦马
     * 枯藤老树昏鸦
     * 枯藤老树昏鸦
     * 断肠人在天涯
     * 枯藤老树昏鸦
     * 小桥流水人家
     */
    }
}
class Test2 extends Test{
    private int score;
    public Test2(){
        super();//相当于显示调用父类有参构造
        System.out.println("断肠人在天涯");
    }

    public Test2(int age,int score){
        super();
        this.score=score;
        System.out.println("小桥流水人家");
    }

}

4.子类重写父类的方法，修饰符范围应该比父类大。

5.静态方法中不能使用super和this关键字，会报错。（静态方法从属于类，随着类的加载而产生比较早，而super和this都是从属于对象，随着对象的创建而生成比较晚，生成时间不同，所以static修饰的方法很可能调用错未创建的对象）

6.package包中有哪些包:

* java中常见的包: java.lang包之外的其他包下的类，使用时需要导包。
* java.lang包:java核心类库，String,System,Math... 该包下的类可以直接使用，无需导包。
* java.util包:工具类。 Arrays,Scanner...
* java.io包:i(input)/o(output)和java中流的输入和输出相关的类库。
* java.net包:网络编程相关的类库。
* java.sql包:与数据库操作相关的类库。
* java.text包:国际化或格式化输出相关的类库。
* java.awt包/javax.swing包:图形化界面相关的类库
*声明包:使用package关键字,必须放在该类的第一行。
*语法: package 包名; eg:cn.zzsxt.oop7;

7.java.lang.Object类中的方法：

8.toString() 返回该对象的字符串表示。如果使用System.out.println(stu);默认调用stu.toString()
* cn.zzsxt.oop6.Student@26ffd553==》
* cn.zzsxt.oop6.Student(包名.类名)+@+16进制表示的hashcode码
* toString()方法经常在子类中重写。

import java.util.Arrays;

public class TestToString {
    public String name="kuangzhisen";
    String []num={"saaaa","sssss","dddd"};

/*
    @Override
    public String toString() {
        return "TestToString [num=" + Arrays.toString(num) + "]";
    }

*/

    public static void main(String[] args) {
        int a;
        TestToString t=new TestToString();
        TestToString tt=new TestToString();
        System.out.println(t);
        System.out.println(tt);
        /*
         * cn.zzsxt.oop0610.TestToString@3294e4f4
         *  cn.zzsxt.oop0610.TestToString@4d43691d
         */

    }
}

9.多态的好处：
A:提高了代码的维护性(继承保证)
B:提高了代码的扩展性(由多态保证)

多态的弊端：
不能使用子类的特有功能。

public class Polymo {
    private int age;
    private int score;
    public void show(){
        System.out.println("乐百惠");
    }
    public static void main(String[] args) {
        Polymo p=new Polymo();
        Polymo zz=new son();//向上转型，子类上升为父类
        son ss=null;
         ss=(son)zz; //向下转型，把向上转型过的父类再转换为子类
         ss.show();
         // System.out.println(ss.name);  向下转型后仍然无法调用子类中的私有属性
    }
}
class son extends Polymo{
    private String name="wangyangyang";
    private int age=;
    public void show(){
        System.out.println("王阳阳！！！！！！！");
    }
}

10.java中可以没有构造函数，其实在创建的对象过程中，系统默认添加一个无参构造。

11.this不能调用静态的属性！this是指当前对象，静态方法是通过类调用的方法，不需要实例化，既然不需要实例化，就没有当前对象，既然没有当前对象那怎么会有this。

12.值类型是存储在内存中的堆栈（以后简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。

       ==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。       equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。

        ==比较的是2个对象的地址，而equals比较的是2个对象的内容。显然，当equals为true时，==不一定为true。

13.hashCode（）和equals（）的关系：

　　在向set集合中添加元素时，先调用hashCode（）方法获取当前对象的hash码，根据对象的hash码与集合中对象的hash码进行比较，如果hash码相同，再调用equals（）方法进行比较内容是否相同。

　　如果hash码不同，将不再调用equals（）方法、

　　如果equals相同，hash码肯定相同；相反，如果hash码相同，equals结果不一定相同。

　　如果，向set结合中添加对象时，想将内容相同的重复项去掉，需要重写hashCode（）和equals（）方法。

14.LinkedHashSet：哈希表+链表结构进行存储。（有序，添加顺序）

15.哈希表（散列表）

　　Y=K(X)=X%7，X为hash码