java面向对象

方法加属性即是类

oo是面向对象，oop面向对象编程

面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据

面向对象的3大特性：封装，继承，多态

面向过程是按步骤一步一步按顺序执行，而面向对象是先分好类，再一步一步实现。

new类，数组，对象

public class Demo5 {
    //值传递
//    public static void main(String[] args) {
//        int a=1;
//        System.out.println(a);
//        change(a);
//        System.out.println(a);
//    }
//    public static  void change(int a){
//        a=10;
//    }
    //引用传递
    public static void main(String[] args) {
        person person = new person();
        System.out.println(person.name);
        Demo5.change(person);
        System.out.println(person.name);
    }
public static void change(person person){
         person.name=\"lang\";
}
}
class person{
    String name;

构造器：

与类名相同，没有返回值

new的本质是使用构造方法，初始化对象的值

new是创建一个对象，在堆中为对象开辟一个空间存储值，new一个类即是将类实列化。new一个数组即是为这个数组开辟空间。

封装，继承，多态都是对象的特性

this调用子类的东西

super调用父类的东西

this，super只能在第一行，不能在一起

super注意点：

构造方法即是代码隐藏在第一行的方法，而super在构造方法的第一行

1.super调用父类的构造方法，必须在构造方法里的第一行

2.super必须只能出现在子类的方法里或者构造方法里

3.super和this不能同时调用构造方法

this注意点：

代表对象不同

1.this：本身调用者这个对象

super：代表父类对对象的应用

前提不同

2.this：没继承也可以使用

super：必须要继承才能使用

构造方法不同

3.this（）；本类的构造

super（）：父类的构造

重写：必须有继承关系，子类重写父类的方法

1.方法名相同

2.参数列表相同

3.修饰符：范围可以扩大，一般为public，publi>protect>default>private

4.抛出异常：范围可以被缩小，但不能扩大 exception>classnotfoundexception

重写：子类的方法名和参数相同，只有方法体不同

为什么需要重写：

1.子类不一定需要父类的功能

快捷键：alt+insert

重写的英文单词：override

可以用private私有化

继承是类与类之间进行继承，子类继承父类公共的一切。

        A a=new A();
        a.text();
        B b = new A();
        b.text();
        //当有static
   输出  A-text
        B-text
        //当无static
 输出    A-text
        A-text

因为b是newA（）出来的，如果在A类有static静态方法时new出来的对象是调用类的方法，又因为a类继承了b类，所以会输出a和b，而没有static时new出来的对象是调用对象的方法，所以输出两个a。

//父类
public class Person {
    public void run(){
        System.out.println(\"run\");
    }
    public void sleep(){
        System.out.println(\"sleep\");
    }
    //子类
    public class Student extends Person{
    @Override
    public void run() {
        System.out.println(\"son run\");
    }
    public void eat(){
        System.out.println(\"eat\");
    }
    //执行以下代码，输出
son run
son run
eat
sleep
        Student s1 = new Student();  
        Person s2 = new Student();//父类的引用指向子类
        s2.run();
        s1.run();
        s1.eat();
        s2.sleep();

多态注意事项：

1.多态是方法的多态，属性没有；

2.父类和子类有联系，classcastexception（父子类型出问题了）

3.存在条件：继承父类，方法需要重写。父类的引用指向子类对象。如father f=new son（）；

4.在方法中有privte和static不能重写。

多态中父类引用指向子类的对象，父类转换成子类属于高向低转向，属于强制转换，会丢失一些方法

static与类一起加载，静态方法可以调用静态方法，不能掉用动态方法

 public class Person {
 static {
        System.out.println(\"静态代码块\");
    }
    {
        System.out.println(\"匿名代码块\");
    }
    public Person() {
        System.out.println(\"构造代码块\");
    }

    public static void main(String[] args) {
        Person person = new Person();
    }
    }

要先将person实例化，在堆里开辟内存，才会执行代码块。先静态代码块且只能进行一次然后就是匿名代码块，最后是构造方法

抽象类里有普通方法，而抽象方法必须要有抽象类。

============================================================================

接口的作用：

1.约束

2.定义一些方法，让不同的类实现

3.接口不能被实例化

4.变量，方法都是抽象的

5.implements可以实现多个接口

6.在implement类里实现接口的方法

7.interface接口只能定义一些抽象的方法，不能具体实例化

异常

捕获异常要范围从小到大

try{

//监控异常

}catch（）{

//捕获异常

}finally{

释放资源

}

快捷键：ctrl+alt+t创建捕获异常

当在类中有其他方法时，要在main方法里对类进行实例化，才能实现其他方法。

如果类中只是一些输出语句的话，不用实例化

来源：https://www.cnblogs.com/anscholar/p/15985525.html
本站部分图文来源于网络，如有侵权请联系删除。