JavaSE--入门

JavaSE——面向对象

面向对象 Object Oriented(OO)

利用封装、继承、多态来实现程序的可维护性、可扩展性和灵活性。

面向对象的三大特性：

封装–维护性：隐藏成员属性和成员方法，以及隐藏成员方法的实现过程。

继承–扩展性：提高代码的重用性，减少冗余代码。

多态–灵活性：父类的引用指向子类的实例

封装——维护性

类Class

对【对象】的抽象，只设计好一个类是无法启动的，需要在其他位置调用这个类

对象Object

对【类】的实例

成员属性

在设计的类中的一些名词性的东西

用来改变根据类设计出的对象的一些固有的特征，定义一些后面会用到的变量，方便进行赋值和运算

成员方法

在设计的类中的一些动词性/行为性的东西

用来启动设计的类

get 和set访问器

• set:给成员属性赋值
• get:提取成员属性的值

public class void main(String[] args){
	
}
class Student{
	public String name;
	public int age;
	public void student{
		System.out.println("大家好，我的名字是"+name+",今年已经"+age+"岁了")
	}
	//给成员属性age赋值
	//将public改为private
	public int setAge ( int nian ){
		// 判断参数是否合理
		return age = nian >= 0 && nian <= 150 ? nian : 0;
	}
	//提取成员属性age
	public int getAge(){
		return age;
	}
}

构造器

构造器的注意事项：

1. 构造器的名称必须和类名一致
2. 一个类中可以定义多个构造器，但是构造器的参数列表必须不同(重载)
3. 如果我们没有手动定义构造器，则Java系统会提供一个默认的构造器给我们使用，一旦我们定义了构造器，则系统会把默认的构造器收回
4. 构造器的作用：实例化对象，给对象赋初始值
5. 代码游离块优先执行

• 隐式构造器

在没有定义出构造器的情况下，文件会自动给定一个隐式的构造器

public 类名(){

}

• 显式构造器

右地时候我们对于构造器会有一定的要求，而自动给定的隐式构造器无法满足，这时候就需要我们自己去定义一个构造器，这个就称为显示构造器。

public class Student {
    public  Student(String name , int age){
        this(name); // 在构造器中调用另一个构造器必须在第一步
        this.setAge(age);
    }
    public Student(String name){
        this.name = name;
    }
    public Student(){

    }
    public String name;
    private int age;

    public int setAge( int nian){
        return age = nian>0&&nian<=150?nian:0;
//        if ( nian > 0 && nian <= 150){
//            age = nian ;
//        }
//        else
//            age = 0 ;
//    }
//    public  int getAge(){
//        return age;
    }
    public void student(){
        if(age != 0)
        System.out.println("大家好，我的名字是"+name+"，今年已经"+age+"岁了");
        else
            System.out.println("输入年龄有误");
    }
}

封装的优点

1. 提高了数据的安全性。别人不能够通过 变量名来修改某个私有的成员属性
2. 操作简单。封装后，类的调用者在使用的时候，只需调用方法即可。
3. 隐藏了实现。实现过程对类的调用者是不可见的，类的调用者只需调用方法即可，不知道具体实现。

继承–扩展性

继承是基于抽象的结果，当面向对象编程的过程中要对类进行抽象, 将抽象的结果形成一个基类, 让其他类去继承这个基类, 使得其他类拥有基类的属性与方法, 减少重复代码的编写与维护.

继承的实现

class 子类 extends 父类 {

} 

• 使用 extends 指定父类
• 子类会继承父类的所有public 的字段和方法
• 对于父类的 private 的字段和方法, 子类中是无法访问的
• 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

//父类/超类
public class animal {
    // 重载
    public animal() {

    }
    public animal(String name , int age){
        this.age =age;
        this.name = name;
    }
    // 成员属性
    public String name ;
    public int age ;
    // 成员方法
    public void say(){
        System.out.println("大家好，我是狗狗"+name+",今年"+age+"岁了");
    }
}

//子类/派生类
public class DOG extends animal{
    //继承父类的两个构造方法
    public DOG(String name , int age){
        super();
    }
    public DOG(){
        super();
    }
}

super关键字

super关键字的使用：

• 在子类的成员属性中，访问父类的成员属性。
• 在子类的成员方法中，访问父类的成员方法。
• 在子类的构造方法中，访问父类的构造方法。

super和this关键字的区别：

• this在本类的成员方法中，访问本类的成员变量。
• this在本类的成员方法中，访问本类的另一个成员方法。
• this在本类的构造方法中，访问本类的另一个构造方法。

我们可以在子类的构造器中显式的使用“super（形参列表）”的方式，调用父类中声明的指定的构造器。“Super(形参列表)”的使用，必须声明在子类构造器的首行。我们在类的构造器中，针对“this(形参列表)”或者“super(形参列表)”只能二选一，不能同时出现。在构造器的首行，没有显示的声明“this(形参列表)”或者“super(形参列表)”，则默认调用的是父类中空参的构造器。

方法的重写

重写的概念

• 在Java一些面向对象的编程语言中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
• 子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。

重写的规定

• 子类重写的方法的方法名和形参列表与父类被重写的方法名和形参列表相同。
• 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符。
• 特殊情况：子类不能重写父类中声明为privite权限的方法。

多态——灵活性

多态的含义

多态是同一个行为具有多个不同表现形式或形态的能力。允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。