Java面向对象05

面向对象

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

三大特征：

封装、继承、多态。

方法

同一包下的类调用其他类的static方法：类名+方法名

调用不是static方法：实例化对象，对象类型 对象名 = 对象值。

static

static方法是和类一起加载的，没有加static的方法需等实例化后再加载。

值传递

public static void main(String[] args){
    int a = 1;
    change(a);
    System.out,println(a);
    
    public static void change(int a){
        a = 10;
    }
}

运行结果：1

类与对象的创建

类实例化后会返回一个自己的对象！

//对象的创建
public class Student{//创建一个Student类
    String name;
    int age;
}
public static void main(String[] agrs){
   Student xiaoming = new Student;//创建Student对象
   System.out.println(xiaoming.name);
}

构造器

1. 和类名相同
2. 没有返回值

public class Student{
    String s;
    public Student(String s){//构造器重载进行类的属性值初始化
        this.s = s;
    }
}

public static void main (String[] args){
    Student s1 = new Student("小明")；
}

作用：

1. new本质在调用构造方法
2. 初始化对象的值

注意点：

1. 定义有参构造之后，如果想使用无参构造，显式的定义一个无参的构造

构造器创建快捷键：alt+insert

封装

高内聚低耦合：高内聚——内部数据操作细节自己完成，不允许外部干预；低耦合——仅暴露少量的方法给外部使用。

属性私有，get/set

意义

1. 提高程序的安全性，保护数据；
2. 隐藏代码的实现细节；
3. 统一接口；
4. 增加系统可维护性。

继承

extend：继承父类的公共属性和方法。

super：调用父类的构造方法，必须在构造方法的第一个。

this：调用自身的构造方法。

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

子类继承父类后默认调用父类的无参构造器，若父类没有无参构造器，则子类必须显示的调用父类的有参构造器（因为默认的构造器是无参构造器）

方法重写——非静态方法

方法重写：子类重写父类的方法。

• 方法名必须一样；
• 参数列表必须相同；
• 修饰符，范围可以扩大；
• 抛出的异常：范围，可以被缩小，但不能扩大。

静态方法是类的方法，而非静态方法是对象的方法

//main
public static void main(String[] args){
    //当test()为静态方法时，b调用B的test(),当test()为非静态方法时，b调用A的test()。
    A a = new A();
    B b = new A();
    a.test();
    b.test();
}
//A
public class A extends B{
    public static test(){
       System.out.println("A==>test");
    }
} 
//B
public class B{
    public static test(){
        System.out.println("B==>test");
    }
}

多态

Father f = new son();

基类：即父类； 派生类：即子类；

对象能执行哪些方法，主要看对象左边的类型，和右边的类关系不大。

父类型可以指向子类，但是不能调用子类独有的方法，而子类可以继承父类的所有方法。

当父类和子类都有同一个方法时，父类引用调用子类方法（不调用父类方法）

多态的作用：扩大可拓展性，如当父类引用指向子类对象时，可以调用子类重写的方法。如下：

abstract class MyShape{
    public abstract void getArea();
    public abstract void getLength();
}

class Circle extends MyShape{
    public static final double PI=3.14;
    double r;
    public Circle(double r){
        this.r=r;
    }
    public void getArea(){
        System.out.println("圆形的面积"+PI*r*r);
    }
    public  void getLength(){
        System.out.println("圆的周长"+2*PI*r);
    }

}

class Rect extends MyShape{
    int width;
    int height;
    public Rect(int width,int height){
        this.width=width;
        this.height=height;
    }
    public void getArea(){
        System.out.println("矩形的面积是"+width*height);
    }
    public void  getLength(){
        System.out.println("矩形的周长是"+(width+height)*2);
    }

}
public class Demo5 {
    public static void main(String[] args) {
       Circle c=new Circle(2.0);
       print(c);
 }
public static void print(MyShape s){    //MyShape s=new Circle(4.0);
        s.getArea();
        s.getLength();
    }
}
————————————————
版权声明：本文为CSDN博主「一大三千@大千世界」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45192252/article/details/95042561

同一个类可以指向不同的对象，不需要再次定义，增加了灵活性，也节省了内存空间。如：

public class Person{
    String name;
}

class Student extends Person{
   public Student(){
      this.name = "学生"；
   }
}

class Teacher extends Person{
   public Teacher(){
       this.name = "老师"；
   }
}
================================================
public class test{
    public void static main(String[] args){
        Person person;
        person = new Student();
        System.out.println("这个人是：" + person.name);
        person = new Teacher();
        System.out.println("这个人是：" + person.naem)
    }
}

/*结果：
这个人是学生
这个人是老师
*/

注意事项：

1. 多态是方法的多态，不是属性的多态；
2. 存在条件：继承条件，方法需要重写，父类引用指向子类对象

instance强制转换

System.out.println(x instance y);//将x与y进行比较，若有继承关系则返回ture，否则返回false

使用instance进行比较时，编译通不通过主要看x的引用类型和y的类型是否有继承关系，结果对不对主要看x的对象类型和y的类型是否有继承关系。

Person student = new Student();//Person是引用类型，指向了Student类型

目的：方便方法的调用，减少重复的代码。

子类可转父类，父类要转子类需强制转换。

static

和类一起加载，只执行一次

import static java.lang.Math.random;//静态导入包

public class Test{
    public static void main(String[] args){
        System.out.println(random());//不需要前缀Math
    }
}

抽象类

1. 不能new，只能靠子类去实现它（重写abstract方法）；
2. 抽象方法只能在抽象类中；
3. 抽象类中也可以有普通方法。

作用：不用重写所有方法，提高开发效率。

接口

public interface 类名{
    //接口内的方法默认都是public abstract类型，可以不加
    //接口内的变量默认都是public static final类型
}

接口内不实现方法，实现方法使用implements继承。

接口不能被实例化，因为接口没有构造方法。

接口可以多继承，如：

public class 类名 implements 接口名,接口名{
    
}

内部类

public class Outer{
    class Inner{        
    }
}

public static void main(String[] args){
    Outer out = new Outer();
    Outer.Inner in = Outer.new Inner(); 
}

一个java类中可以只能有一个public class，但是可以有多个class