java：面向对象（Leak filling）

Posted 2020-09-22 咫尺天涯是路人丶

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java：面向对象（Leak filling）相关的知识，希望对你有一定的参考价值。

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(20);
        Test2 tt2=new Test2();
        Test2 t2=new Test2(18,99);
    /*
     * 古道西风瘦马
     * 枯藤老树昏鸦
     * 枯藤老树昏鸦
     * 断肠人在天涯
     * 枯藤老树昏鸦
     * 小桥流水人家
     */
    }
}
class Test2 extends Test{
    private int score;
    public Test2(){
        super(2);//相当于显示调用父类有参构造
        System.out.println("断肠人在天涯");
    }
    
    public Test2(int age,int score){
        super(1);
        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=2;
    public void show(){
        System.out.println("王阳阳！！！！！！！");
    }
}