JavaSE基础-面向对象

类的定义：

属性+方法=一个类；

以类的方式组织代码，以对象的组织（封装）数据；

类和对象的区别:

类是一种抽象的数据类型，他是对某一些事务整体描述/定义，但是并不能代表某一具体事物

例：动物，植物

对象是抽象概念的具体实例

例：张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例

一只小猫

类是对象的模板，对象是类的实体；

创建对象：

创建对象：

1、导包：指出需要使用的类，在什么位置

import 包名称.类名称；

对于和当前类属于同一个包的情况，可以省略导包语句不写

2、创建：

格式：类名称 对象名 = new 类名称（）；

3、使用：

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名（参数）

例：

public class Demo02 {

    //成员变量
    //成员变量定义在类之中，在方法外边
    //成员方法不要写static关键字

    //通常情况下，一个类不能直接使用，需要个人根据类创建一个对象，才能使用
    String name;
    int age ;

    //成员方法
    //吃饭
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void study(){
        System.out.println("学习");
    }

public class Demo03 {
    public static void main(String[] args) {
        //导包，我需要使用的Demo02类，和Demo03类在一个包下，所以省略导包语句

        //创建,格式
        //类名称 对象名 = new 类名称（）；
        Demo02 stu = new Demo02();//根据Demo02这个类，创建一个stu的对象

        //使用 使用齐中的成员变量
        System.out.println(stu.name);//null
        System.out.println(stu.age);//0

        //改变对象当中的成员变量数值内容
        stu.name = "暮商";
        stu.age = 18;
        System.out.println(stu.age);
        System.out.println(stu.name);
        System.out.println("==========AAA===========");

        //使用对象的成员方法
        //对象名.成员方法名（）
        stu.eat();
        stu.study();
        stu.sleep();
    }

成员变量的注意事项

如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

使用对象作为方法的参数：

当一个对象作为参数，传送到方法当中的时候，视机上传递进去的是对想的地址值。

局部变量和成员变量的区别

1、定义的位置不一样，局部变量：在方法的内部；成员变量：在方法的外部，直接写在类之中

2、作用范围不一样

局部变量：只有方法当中可以使用，出了方法就不能用；

成员变量：整个类都可以使用

3、默认值不一样

局部变量：没有默认值，如果想使用，必须手动进行赋值

成员变量：如果没有赋值，会有默认值，规则和数组一样。

public class Demo04 {
    
    String name;//成员变量
    
    public void method(){
        int num;//局部变量
    }

构造方法：

构造方法是一种特殊的方法，利用构造方法能够初始化对象的属性，

构造方法必须与定义它的类有完全一样的名字，作用是实现属性的初始化。

构造方法的结构如下：

[修饰符] 类名（参数列表）{
//方法体
}

构造方法有以下的特点：

1、具有和类相同的名称

2、不含返回值

3、不能在方法中用return语句返回一个值；

4一般访问权限为Public

构造方法的作用有：

1、完成对象的创建，即完成对象的实例化

2、一般使用构造方法来完成对属性的初始值

提示：

1、如果类里没有构造方法，系统会默认有一个无参的什么也不做的构造方法；

2、如果类里定义了有参的构造方法，则默认的无参的构造方法就不存在了；

3、构造方法是实例化对象时才能调用，不能随意调用

this关键字

this关键字应用的情况：

1、方法中的变量名和属性重名时

2、在一个构造方法中，调用其它重载的构造方法

3、返回当前对象的引用

继承

继承

继承是从已有的类中派生出新的类，新的类能拥有已有类的属性和行为，并能扩展新的属性和行为。

父类 ：public class person{}

子类：public class student extends person {}

一个子类只能有一个父类，但一个父类可以有多个子类；

在继承关系中：

子类可以得到父类的属性和方法，这是从父类继承来的；

子类可以添加新的属性和方法，添加父类所没有的；

子类可以重新定义父类的属性和方法，修改父类的属性和方法，为自己所用。

例：

class Employee {
    String name;
    String birth;
    double salary;
    public void getDetail() {
        System.out.println("name=" + name + " age=" + birth);
    }
    double getSalary() {
        System.out.println(salary);
        return salary;
    }
}
class Worker extends Employee {
    double dressAllowance(){
        double allownance = 200;
        return allownance;
    }
}
public class TestWorker {
    public static void main(String args[]){
    //创建一个引用worker的对象
        Worker w = new Worker();
        //worker的类引用了父类的getDetail方法
        w.getDetail();
    }
}
输出结果：name=null age=null

继承关系下构造方法的调用：

public class Ex_Consructor2 {
    public static void main(String[] args){    
        BB b = new BB();      
    }
}
class  AA {
    int a ;  
    AA(int a){    
        this.a = a;
        System.out.println("AA构造方法");      
    }
}
class BB extends AA {  
    BB(){
        System.out.println("BB构造方法");      
    }
}

当父类中没有无参的构造方法时，默认情况下，创建其子类对象时会出错，如果要调用父类的有参构造时，可以借助super完成：

将上面的子类BB改写成：

class BB extends AA {
     BB() {
        super(1);
        System.out.println("this is B constructor");
     }
}

super关键字

super（）的作用是调用父类的构造方法，调用构造方法时需注意：

1、只能出现在子类的构造方法中，切必须时第一行；

2、super（）中的参数，决定了调用父类哪个构造方法；

this()的作用是调用本类的构造方法，调用构造方法时需注意：

1、只能写在构造方法的第一行；

2、使用这两个关键字的时候需要注意同一个构造方法中super（）和this（）不能同时出现；

例：

public class Person {     //父类Person
    String id; 
    String name; 
    public Person(){  }
    public Person(String id,String name){
        this.id = id;
        this.name = name;        
    }
}
public class Teacher extends Person{   //子类Teacher
    public Teacher(){
        super();//调用父类中public Person()方法
    }
    public Teacher(String id,String name){
    //调用了父类中public Person（String id，String name）
        super(id,name);
    }
}

使用访问权限修饰符对类的成员进行控制。

访问权限修饰符:

构造方法和类的权限通常为public，private的权限最先，限制类外的访问，一般把属性设为private。

访问权限修饰符：public> protected > friendly > private

父子类在一个包中，子类可以直接访问父类中的非私有属性；

父子类不在一个包中，子类可以直接访问 public 类中的， public 属性和 protected 属性。

构造器访问：

1、读取： getter方法

getter方法的定义形式如下：

public 返回值类型 get属性名(){ return 属性名； }

2、设置：setter方法

setter方法的定义形式如下：

public void set属性名(数据类型参数值){ 属性名 = 参数值； }

public class Demo05 {
    String name;
    private int age;

    //这个成员方法，专门用于向age设置数据
    public  void show(){
        System.out.println("我叫"+name+","+ "今年" +age);
    }
    //这个成员方法，专门用于获取age的数据
    public void setAge(int num){//这里的setAge为固定用法，前面必须用set
        if (num<100&&num>0){
            age=num;
        }
    }
    public int getAge(){//固定用法，前面必须要用get
        return age;
    }
package JavaSE.MianxiangDuiXiang;

public class Denmo06 {
    public static void main(String[] args) {
        Demo05 person = new Demo05();
        person .show();

        person.name = "暮商";
        //person.age = 18;用了private之后，这样写直接访问private内容，属于错误写法
        person.setAge(18);
        person.show();
    }
}

多态

多态存在的三个必要条件：

1、要有继承、或实现

2、要有重写

3、父类引用指向子类的对象

练习：

在停车场收费系统中，收费者会根据车型的不同收取不同的停车费，其中，

客车：15元/小时，货车：12元/小时，轿车：8元/小时

基类：

public class che {
    String name;
        public che(){
    
        }
        public che(String name){
         this.name =name;
       }

       public void time(int hour){
    
    System.out.println();
       }

子类1：

public class che2 extends che{
    public che2(String name ){
        super(name);
    }
@Override
public void time(int hour) {
//对父类的time方法的重写
    int showfei = hour *15;
    System.out.println(name+":"+showfei+"元");
    }
}

子类2：

public class che2 extends che{
    public che2(String name ){
        super(name);
    }
@Override
public void time(int hour) {
    int showfei = hour *15;
    System.out.println(name+":"+showfei+"元");
    
}

测试类：

public static void pay(che c,int hour){
    c.time(hour);
}

public static void main(String[] args) {
    pay(new che2("客车"), 6);
    
}

final关键字

可以修饰程序中的多种元素，包括类、方法、属性和局部变量。使用final修饰的类不能被继承。使用final修饰的变量(属性和局部变量)不能被重新赋值，

在程序中经常使用一些常量，如圆周率，没必要在程序中频繁的修改它，那么我们可以：

首先把它设置为静态static，多个实例共享该常量，没有必要每个对象保存一份；

其次，设置为final类型，赋值以后不能再改变；

抽象类

抽象类的结构：

[public] abstract class 类名[extends父类][implements接口列表]
{
属性声明及初始化；
抽象方法的声明；
非抽象方法声明及方法体；
}

用abstract声明的类，称之为抽象类，抽象类不能被实例化。

如果成员方法没有方法体，该类必须声明为抽象类；

但抽象类中的方法也可以是抽象防范，也可以是普通方法；

抽象方法必由子类重写

接口

接口是一种用于描述类对外提供功能规范的、能够多重继承的、特殊的抽象类。

接口中只能定义静态常量和抽象方法。

接口定义的语法：

[public] interface 接口名 [extends 父接口列表]{
     // 属性声明
     [public] [static] [final] 属性类型属性名 = 常量值 ;
     // 方法声明
     [public] [abstract] 返回值类型方法名 ( 参数列表 ) ;
}

实现接口：

语法格式如下

class 类名 [extends 父类] [implements 接口列表]
{
 覆盖所有接口中定义的方法；
}

一个类可以实现多个接口，但只能继承一个类。

接口中必须覆盖接口中的所有方法，而且都是公开的。

 

Java类中可以实现多个接口，弥补了Java单继承的局限性。

格式：class AA extends BB implements CC,DD,EE;

public class  A  implements IA, IB{
    public  int  Action1(){    
        System.out.println("this is Action1! ");
    }‘
    public  int  Action2(){
        System.out.println("this is Action2! ");
    }
    public void function(){
        System.out.println("this is  function from  IB ! ");
    }
}

接口和接口之间可以继承，而且可以多继承

抽象类和接口的区别：

成员变量：

抽象类中可以是普通变量

接口中只是常量，即时由final static来修饰变量，无论写还是不写

成员方法：

抽象类中可以有抽象方法，也可以没有

接口中只能是抽象方法，不论写不写abstract

构造方法:

抽象类中可以定义构造防范提供给子类使用

接口中不能有构造方法

继承：

抽象类只能继承自类，只能单继承。

接口只能继承自接口，而且可以多继承