java基础

Posted 2020-09-27 风尘小白沙

、面向对象基础

• 类与对象
• 封装
• 构造方法
• 方法
• 重载
• 对象数组
• this关键字
• static关键字

1.1类与对象

类：类是抽象的，概念上的，共性的，是对象的模板

对象：个体，具体的，可以看见的，对象是个性的，是该类事物的每个个体，也称为类的实例。

类的组成：

• 方法
• 属性

对象的创建

• 类名 对象名= new 类名（）

对象的引用传递问题

• 注意引用的是对象堆内存的空间

1.2封装

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

封装的概念：使用private实现类的封装，用private关键字修饰属性，修饰方法，private的含义是私有的，使用private修饰的方法和属性不能被外部直接访问。

封装的特性：通过使用封装的属性，要通过get,set方法来获得和设值。

1.3构造方法的问题

构造方法的作用：构造方法的作用主要是用来构造对象并且为对象的属性赋值。构造方法的定义规则：

• 无需任何的放回值类型
• 方法名称必须和类重名

1.4方法

方法的定义

public|private|protected|默认  + static|默认|synchroized|native|abstract+返回值类型|void|空+方法名称（参数）+ throws Exception{
   方法体

}

方法的调用：

• 如果是普通方法，通过对象去调用
• 如果是构造方法，通过实例化去调用
• 如果是静态方法，可以通过类名直接访问

2.4对象数组

以类作为数组的类型，以对象作为数组的元素

Person p[] = new Person[10];//一类作为数组的类型,元素就是对象
        for (int j = 0; j < p.length; j++) {
            Person px = new Person("张三",20+j);
            p[j] = px;
        }
        
        for (int j = 0; j < p.length; j++) {
            Person per = p[j];
            System.out.println(per.getName()+"===="+per.getAge());

        }

2.5方法的重载

在同一个类中，方法的名称相同，返回值的类型相同，但是参数的个数，类型，顺序不同就叫做重载，重载是面向对象多态性的一个体现。

//吃饭
    public void eat(){
        System.out.println(name + "在吃饭");
    }
    public void eat(int x){
        System.out.println(name + "在吃饭，吃了"+ x +"碗。");
    }

2.6this的关键字的用法

this关键字可以表示当前对象

this关键字可以表示当前类的属性

this关键字可以表示调用当前类的方法

this关键字调用当前类的构造方法

2.7static关键字

• static变量的声明和使用
• static方法的声明及使用
• static方法块的声明及使用

static变量：使用static修饰的变量就叫做静态变量

static方法：使用static修饰的方法就叫做静态方法

public class OopDemo01 {
    static int score = 70;//静态变量
    double salary = 5000.00;//普通变量
    public static void add(){//静态方法
        //eat();静态方法中不能调用非静态方法
        System.out.println(score);
        //System.out.println(salary);静态方法不能调用非静态变量
    }
    public void eat(){//普通方法
        add();//非静态方法可以调用静态方法
        System.out.println(score);//普通方法可以调用静态变量
        System.out.println(salary);
    }
    public static void main(String[] args) {
        
    }

对于静态方法调用的问题

• 静态方法中不能调用非静态方法，静态方法不能调用非静态变量
• 非静态方法可以调用静态方法，普通方法可以调用静态变量

栈：保存属性（变量）名称

堆：保存属性（变量）值

全局数据区： static修饰的变量

全局代码区：static修饰的方法

• 　　代码块：使用一对{}围起来的就是代码块：
•        普通代码块：写在方法中的语句
•        构造块（实例块）：直接写在类中的语句，优于构造方法先执行，在实例化多个对象的时候，构造块执行多次
•        静态块：直接写在类中，使用static修饰，是优于构造块先执行，在实例化多个对象的时候，静态块只执行一次

面向对象高级部分

• 继承
• 抽象类
• 接口
• 多态

2.1继承

继承的作用：

• 通过继承可以简化子类的定义
• 扩展子类的功能

子类通过extends关键字继承父类

继承的特点：子类可以继承父类一切非私有的属性和方法

继承的规定：

• java只支持单继承，一个类不能同时有多个父类（一个人只有一个父亲一样）
• java支持多层继承，一个类继承自父类，父类也可以自爷爷类

子类的实例化过程：实例化子类对象的时候会先调用父类的构造方法，说明父类也进行了实例化对象操作，实际上调用父类的构造方法构造父类对象就是为子类对象开辟空间，而且可以为父类的属性初始值。

super关键字的使用：父类也称为超类（）

• super关键字可以调用父类的属性（非私有）
• super可以调用父类的方法（非私有）
• super关键字可以调用父类的构造方法（必须放在首行）

方法的复写（）

方法的重写的定义：方法的返回值的类型，方法名称，方法里的参数的个数，顺序，类型一致，就是方法的复写，子类复写父类的方法，调用子类的方法，扩展父类的属性，复写分类的方法子类的访问权限必须要大于等于父类的方法，父类的方法不能为private。

复写和重载的区别：

序号	重载	覆写
1概念	名称相同，参数的个数类型顺序不同	方法名称相同，访问权限不小于父类被覆写方法，参数相同，返回值类型相同
2范围	在同一类中	在继承关系中，子类覆写父类方法

 访问修饰符

位置	private	默认	protected	public
同类	V	V	V	V
同包的类	X	V	V	V
不同包的字类	X	X	V	V
不同包且不是字类	X	X	X	V

public|private|protected|默认  + static|默认|synchroized|native|abstract+返回值类型|void|空+方法名称（参数）+ throws Exception{
   方法体

}

2.3抽象类

final :在java中final可以修饰变量方法，类

• 使用final修饰的变量就是常量，只能赋值一次，而且常量一般使用大写字母来表示常量名称。
• 使用final修饰的方法不能被子类复写
• 使用final修饰的就是太监类，不能拥有子类
• 抽象类：使用abstract修饰的类就是抽象类
• 抽象方法：使用abstract修饰的方法就是抽象方法

package com.wanczy.oopHightLevelDemo;

public abstract class OopDemo003 {//定义就是抽象类
    
    public abstract void eat();//声明抽象方法
    
}

抽象方法只需要声明不需要实现，有一个抽象方法必须定义为抽象类

抽象类和普通类相比区别：抽象类比普通类多了抽象方法，普通类中的所有定义都可以在抽象类中使用

抽象类的使用规则：

• 抽象类本身不能实例化
• 抽象类中的抽象方法只需要声明，不需要实现
• 含有抽象方法的类必须声明为抽象类
• 抽象类必须要有子类，不然抽象类没有任何意义，抽象类的子类必须要复写抽象类中的全部抽象方法。
• 抽象类中可以有抽象方法
• 抽象类中不可以用final声明

范例：现在有两类员工，一类是技术类，一类是销售类，两种员工的提升工资的方式不一样，技术员工类按照岗位等级提升，销售员工按照上一年度销售业绩来提升工资

package com.wanczy.abstractDemo;

public abstract class Employee {
    private String name;
    private double salary;//工资
    
    public Employee() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Employee(String name, double salary) {
        super();
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public abstract void updSalary();//提升工资的抽象方法
}

package com.wanczy.abstractDemo;

public class TechEmployee extends Employee{
    private String post;//岗位等级
    @Override
    public void updSalary() {
        // TODO Auto-generated method stub
        double salary = super.getSalary();
        if(this.post .equals("高级工程师")){
            super.setSalary(salary*1.05);
            
        }else if(this.post.equals("中级工程师")){
            super.setSalary(salary*1.1);
        }else if(this.post.equals("初级工程师")){
            
            super.setSalary(salary*1.15);
        }
        
    }
    public String getPost() {
        return post;
    }
    public void setPost(String post) {
        this.post = post;
    }
    public TechEmployee(String post) {
        super();
        this.post = post;
    }
    public TechEmployee() {
        super();
        // TODO Auto-generated constructor stub
    }
    public TechEmployee(String name, double salary,String post) {
        super(name, salary);
        this.post = post;
        // TODO Auto-generated constructor stub
    }
    
    
    
}

package com.wanczy.abstractDemo;

public class OopDemo01 {
    public static void main(String[] args) {
        Employee e = new SaleEmployee("长桑",3000,100);
        e.updSalary();
        System.out.println(e.getSalary());
    }
}    

通过以上程序，我们可以发现，如果以后出现其他的员工类型，提升工资的方式不同，可以编写抽象类的字类完成，不需要更改顶层设计。也就是说抽象类的作用就是在于可以方便程序的扩展。 　　

2.4接口

接口的声明使用interface，接口只有常量和抽象方法；

package com.wanczy.oopDemo;

public interface InterfaceDemo01 {
    //常量
    //抽象方法
    public abstract void eat();
    public abstract void run();
}

如果说一个抽象类只有抽象方法和常量的话，我们就可以使用接口来表示。接口中没有子类的概念，实现类，实现类通过implements实现接口，必须覆写接口中所有的抽象方法。

接口的使用规则：

• 接口中访问权限永远都是public，public可以省列，省列后依然时public
• 接口中的方法都是抽象方法，可以省列abstract，省列后依然是abstract方法
• 接口中的常量可以省列final，省列后依然是常量
• 接口在程序中叫实现，接口必须通过实现类实现，也必须要有实现类，不然接口没有意义
• 接口本身不能实例化
• 接口与接口之间可以继承，一个接口可以同时继承多个父接口，子接口中继承了父接口中所有抽象方法和常量
• 实现类也可以实现多个接口，如果实现的多个接口中，有相同的抽象方法，那么实现类只需要复写一次

抽象类与接口的区别

	抽象类	接口
相似	不能直接实例化，抽象类通过子类实例化，接口通过实现类实例化
不同	包含抽象方法、一般方法、变量、长流昂、构造方法	常量和抽象方法
	抽象类可以实现接口	接口不继承抽象类
	单继承的局限性	多继承多实现

2.7多态

多态的核心就是子类对象作为父类对象来使用，抽象类的子类对象作为抽象类对象使用，实现类对象作为接口的对象来使用。

3总结

理解抽象类和接口的区别

理解重载和覆写的区别

熟记继承的特点以及规定（super关键字的使用）