java面向对象编程

一、类与实例

　　类的定义：class 类名（一般大写字母开头，命名规则驼峰命名）

　　类是抽象概念：例如人类，是不存在的

　　

class Person{
    private String name;
    private int age;
    public void setName(String name){
        if (name==null || name.isEmpty()){
            throw new IllegalArgumentException("invalid name");
        }
        this.name = name;
    }
    public void setNameAndAge(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
}

　　实例：类的具体化，例如：张三、李四

　　　　创建实例：类 实例名 = new 类();

　　　　访问实例变量：实例名.变量

        Person ming = new Person();//创建实例
        ming.setName("小明");//调用实例方法
        ming.setAge(12);
        String name = ming.getName();
        int age = ming.getAge();

　　方法：

　　　　定义方法：

　　　　　　修饰符 方法返回类型 方法名(方法参数列表) {
    　　　　若干方法语句;
    　　　　return 方法返回值;
　　　　　　}

　　　　实例调用方法：实例.方法（）

　　　　在方法内部可以使用this（代表实例）来访问类的属性和方法

  　 // 多个参数
 　　public void setNameAndAge(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    private String[] names;
    // 可变类型  类型... 参数名  会转变为数组
    public void setNames(String... names){
        this.names = names;
    }

　　构造方法：

　　　　修饰符  类名（方法参数）{}

　　　　构造方法作用：构造方法用来初始化实例，当类中没有构造方法时，系统中会默认创建一个没有参数没有任何执行语句的构造方法

　　　　构造方法调用：使用new操作符 

　　　　构造方法定义：一个类中可以有多个构造方法，调用时会根据参数个数、位置、类型进行区分，类中构造函数还可以调用其他构造函数，使用this(参数)来调用

　　　　具体代码实现：

　　　　　　

public class Main {

    public static void main(String[] args) {
        // 调用没有参数的构造方法
        Person ming = new Person();
        String name = ming.getName();
        int age = ming.getAge();
        System.out.println(name+age);

    }
}

class Person{
    private String name;
    private int age;

    // 构造方法  没有void修饰 方法名与类名相同  调用构造方法必须使用new操作符
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    // 没有参数，没有执行语句的构造方法
    public Person() {
        this("Unnamed");
    }
    public Person(String name){
        // 调用构造方法使用this(参数)
        this(name,18);
    }
    public void setName(String name){
        if (name==null || name.isEmpty()){
            throw new IllegalArgumentException("invalid name");
        }
        this.name = name;
    }
    public void setNameAndAge(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
}

 

 　　方法重载：

　　　　

package com.company;

/**
 * @Time :2020/7/17 10:57
 * @Description: <方法重载--方法名相同，但参数不同>
 * @作者 :aiyumo
 */
public class MethodOverload {
    public static void main(String[] args){
        String s = "Test string";
        int n1 = s.indexOf('t');
        int n2 = s.indexOf("st");
        int n3 = s.indexOf("st", 4);
        System.out.println(n1);
        System.out.println(n2);
        System.out.println(n3);
    }
}

 

 类的继承

　　class 子类 extends 父类/基类/超类{}

　　所有的类默认都继承Object

　　子类继承父类的所有非private字段和方法除构造方法外，父类可以使用protected来修饰字段

　　子类访问父类的字段：super.fieldname、this.fieldname、fieldname  编译器会自动定位到父类中的字段

　　任何类的构造方法，第一行语句必须是调用父类的构造方法，如果没有，编译器会自动添加一个super()。在父类中存在非默认构造函数时，子类中的构造方法必须使用super(参数)来调用父类构造函数。

　　具体代码：

　　

/**
 * @Time :2020/7/17 11:23
 * @Description: <类的继承>
 * @作者 :aiyumo
 */
public class ExtendsTest {
    public static void main(String[] args){
        Student stu = new Student("xiaoming",12,68);
        stu.printParentField();
        System.out.printf("%s,年龄：%d,成绩为%d",stu.name,stu.age,stu.score);
    }
}
class Person2{
    protected String name;
    protected int age;

    public Person2(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
/*  Student类继承了Person2类的所有字段与方法，
    注意：子类不要定义与父类相同的字段，
    子类不能访问父类的private字段和方法，用protected修饰的字段可以被子类访问
    子类可以通过super.fieldName、this.name、name来访问父类的字段，其中super代表父类
    */
class Student extends Person2{
    protected int score;

    public void printParentField(){
        System.out.println(this.name+this.age);
        System.out.println(name+age);
        System.out.println(super.name+super.age);
    }
    public Student(String name,int age,int score){
        /*
        任何class的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句super();
        如果父类没有默认的构造方法，子类就必须显式调用super()并给出参数以便让编译器定位到父类的一个合适的构造方法。
        子类不会继承任何父类的构造方法。子类默认的构造方法是编译器自动生成的，不是继承的
        */
        super(name,age);//自动调用父类的构造方法
        this.score = score;
    }
}

 　　类的强制转换

　　　　1、向上转型：把一个子类类型变为父类类型的赋值  子类>父类>Object

　　　　

Person2 p = new Student("xiaoming",12,68);  //父类
Student s = new Student("xiaowang",13,72);  // 子类
Person2 p1 = s;
Object o1 = s;
Object o2 = p;

 

　　　　2、向下转型：类类型强制转换为子类类型

　　　　　  向下转型时可以使用instanceof来判断类的实例是否是指定的类型  实例变量  instanceof  类型   return  bool

Person2 p2 = new Person2("xiaoli",14);
Student s1 = (Student) p1;
Student s2 = (Student) p2;  // java.lang.ClassCastException

　　　　

 　　　　java14中可以使用  实例变量  instanceof  类型  类型变量     可以直接转换，避免后面强制转换　　

Person2 p3 = new Student("xiaozhang",14,72);
// instanceof来判断变量指定的实例是否是指定的类型  实例 instanceof 类 返回bool
System.out.println(p3 instanceof Person2); // true
System.out.println(p3 instanceof Student); // false
// java14后可以在判断时，直接转换 if （p3 instanceof Student s3）
if (p3 instanceof Student){
        Student s3 = (Student) p3;
}