JAVA第四章

面向过程和面向对象的设计思想

面向过程:procedure oriented programming 缩写 POP

分析出解决问题所需要的步骤然后把步骤一步一步实现

面向过程直接关注流程

面向对象:object oriented programming 缩写 OOP

以分类的方式进行思考和解决问题

面向对象先对整体关系作出分类然后根据不同的类深入细节的处理。

面向对象的思想符合人类的认知习惯

java类

概念:对现实事物的抽象实际生活中先有对象后有类(概念)

结构:

①成员变量(事物属性的描述)

②方法(事物的行为功能)

③构造方法(用于创建对象)

④代码块

⑤内部类

三步走

第一步:发现类

[访问权限修饰符][修饰符] class 类{
}
//有public修饰的类 类名与文件名一致
//无public修饰的类 类名可与文件名不一致

第二部:定义类的成员变量(共有属性)

String name;
String hobby;
int height;
int weight;
String character;

第三部:定义类的成员方法(功能/行为)

public void study(){
    System.out.println(name+"热爱学习");
}
public void play(){    
    System.out.println(name+hobby);
}

总结类和对象:

类:对现实事物的抽象是模块模型

对象:从类中创建的

成员变量

定义在类中方法体之外

数据类型可以是java中的任意类型

成员变量可以初始化也可以不初始化(不初始化则使用默认值)

创建对象时会从类中向对象中复制一份成员变量

在构造方法成员方法代码块中可以使用成员变量

局部变量

定义在方法构造方法代码块之外

数据类型可以是java中的任意类型

使用前必须初始化赋值

形参也属于局部变量

局部变量仅在该方法中调用方法结束后自动销毁

成员方法

定义在类中没有被static修饰

通过对象调用

构造方法

作用:用来初始化新构建的对象

特点:

①构造方法名与类名相同没有返回值且不需要void修饰

②每个类中都至少有一个构造方法也可以定义多个

每创建一个对象时至少调用一个构造方法

如果类中无构造方法会默认提供一个构造方法

一旦定义有参的构造方法默认的失效

方法重载

在同一个类中有多个方法名相同但参数不同的方法

区分条件:参数个数参数类型参数顺序

方法重载与返回值无关

成员方法也可以重载

package day2;

public class Demo1 {
    
    public Demo1(){
        System.out.println("无参的构造方法");
    }

    public Demo1(String n,String s){
        System.out.println("有2个参数的构造方法");
        System.out.println("方法类型:string string");
        System.out.println(n+"t"+s);
    }
    public Demo1(String n,int a){
        System.out.println("有2个参数的构造方法");
        System.out.println("方法类型:string int");
        System.out.println(n+"t"+a);
    }
    public Demo1(String n,int a,float f){
        System.out.println("有3个参数的构造方法");
        System.out.println("方法类型:string int float");
        System.out.println(n+"t"+a+"t"+f);
    }
    public static void main(String[] args) {
        String name;
        String sex;
        int age;
        float wight;

        Demo1 test1 = new Demo1();
        Demo1 test2 = new Demo1("包子", "女");
        Demo1 test3 = new Demo1("包子", 20);
        Demo1 test4 = new Demo1("包子", 20, 98);
    }
}

值传递和引用传递

基本类型:值传递

引用类型:地址传递

对象与引用

this关键字

当变量名与成员变量名一致时 this表示当前正在操作的对象

语法:this.成员变量名

用于区分成员变量和局部变量

static关键字

概念:静态的可以用来修饰属性,方法,代码块,内部类

特点:被static修饰的内容

①随着类加载而加载

②优先于对象存在

③可以被所有对象共享

④可通过对象名直接调用

package day3;

import day1.ZhengHun;

public class StaticPro {
    String name; //不建议使用static修饰 因为name每个对象不同
    int age;
    static String country = "中国"; //常量

    public void test() { //无static修饰可调用以上属性
        System.out.println(name);
        System.out.println(country);
    }

        
    public static void test2() { //static修饰方法,类方法
    //    System.out.println(name); //报错 static优于对象存在
        System.out.println(country);
    }

    public static void main(String[] args) {
        StaticPro zs = new StaticPro();
        zs.name = "张三";
        zs.age = 20;
        zs.test();
        System.out.println(StaticPro.country); //静态资源随着类加载而加载 可直接调用
        StaticPro ls = new StaticPro();
        ls.name = "李四";
        ls.age = 21;
        ls.test();
    }
}

代码块

概念:类似一个没有名字的方法

分类:

实例代码块(在创建对象之后执行)

静态代码块(在类加载时执行)

类什么时候加载?

①main方法在哪个类中执行该类加载

②创建某个类的对象时

③调用某个类中静态属性,方法

注意:若只使用类中的静态常量不加载整个类(final static)

package day3;

public class DaiMaKuai {
    static String country = "China";
    int age = 10;

    {
        System.out.println("实例代码块"); //调用构造方法后调用 创建一次对象就调用一次
    }
   
    static{
        System.out.println("静态代码块1"); //只执行一次 先于非静态
    }
    static{
        System.out.println("静态代码块2"); //有多个静态时按先后顺序执行
    }

    public static void main(String[] args) {
        new DaiMaKuai();
        new DaiMaKuai();
        System.out.println(DaiMaKuai.country);

        new DaiMaKuai();
        new DaiMaKuai();
    }
}

包(package)

概念:为了更好的组织类 java提供了包机制用于区别类名的命名空间

作用:避免类重名按功能管理类控制访问权限

命名规则:

①包名小写

②项目类型:com(商业的) org(非盈利组织) edu(教育) gov(政府)

③公司名称:huawei sun

④项目名称:oa erp cms

⑤功能模块:窗口/视图层数据访问层服务层工具类

访问权限修饰符

作用:修饰类,成员变量,成员方法,内部类控制对其访问的权限(与包密切相关)

public	公共的	修饰类成员变量成员方法内部类
protected	受保护的	修饰成员变量成员方法内部类
(default)	默认的	修饰类成员变量成员方法内部类
private	私有的	修饰成员变量成员方法内部类

访问权限(成员变量成员方法)

	同类	同包	不同包子类	不同包不同类
public	√	√	√	√
protected	√	√	√
(default)	√	√
private	√

面向对象的三大特征封装

概念:

概念:将类的某些信息隐藏在类内部(用访问权限修饰符来实现)

不让外部直接对其访问可以通过特定方法对隐藏信息进行访问便于控制

package edu.ffyc.javaOOP.FengZhuang;

public class Demo {
    
    private String name;

    public Demo(){

    }
    public Demo(String name){

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

package edu.ffyc.javaOOP.FengZhuang;

public class TestDemo {
    public static void main(String[] args) {
        Demo zrx = new Demo();
        zrx.setName("小张");
        System.out.println(zrx.getName());
    }
}

扩

设计模式:解决某一类问题的方案(模式)

单例模式:让一个类在一个程序只能建造一个对象

步骤:

将构造方法私有化使其在其他类中不能随便使用

提供一个方法用static修饰

package edu.ffyc.javaOOP.DanLi;

public class Demo{
    private static Demo li = null;
    private Demo(){

    }
    public static Demo getDanLi(){
        if (li == null){
            li = new Demo();
            return li;
        }
        return li;
    }
}

package edu.ffyc.javaOOP.DanLi;

public class TestDemo {
    public static void main(String[] args) {
        System.out.println(Demo.getDanLi());
    }

}

继承

概念:子承父类实现代码重用父类/基类---->子类/派生类

条件:两者属于同一类是is-a关系

作用:①实现代码重用 ②扩展性好:子类除了继承父类的功能外还可以扩展自己的功能

继承:

①关键字:extends

②子类可以访问父类中的所有非私有属性和方法

③将子类的共有属性存放在父类中

④一个子类只能继承一个父类

⑤子类中可以扩展特有属性和方法

传递性:

①C继承B B继承A 则C可以调用A,B中的非私有属性和方法

②当一个类没有显示的继承某个类时那么这个类默认继承Object类(所有类的基类)

package edu.ffyc.javaOOP.extends_person;

public class Person { //父类是Object类
    private String name;
    private int age;
    public void play(){
        System.out.println("贪玩是人的天性");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package edu.ffyc.javaOOP.extends_person;

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.sql.SQLOutput;

public class Student extends Person{ //父类是Person类
    private String hobby;
    public void flag(){
        System.out.println("好好学习,天天向上");
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

package edu.ffyc.javaOOP.extends_person;

public class Zhang extends Student{ //父类是Student类
    String sex;
    public void work(){
        System.out.println("写代码使人秃头");
    }
}

package edu.ffyc.javaOOP.extends_person;

public class Test {
    public static void main(String[] args) {
        //调用父类的父类中的属性和方法
        Person person = new Person();
        person.setName("小张");
        person.setAge(20);
        System.out.println("姓名:"+person.getName());
        System.out.println("年龄:"+person.getAge());
        person.play();

        //调用父类中的属性和方法
        Student student = new Student();
        student.setHobby("敲代码");
        System.out.println("他的爱好是"+student.getHobby());
        student.flag();

        //调用自己的属性和方法
        Zhang zrx = new Zhang();
        zrx.sex = "男";
        System.out.println("性别:"+zrx.sex);
        zrx.work();
    }
}

继承中的构造方法:

在创建子类对象后调用构造方法时从上向下的调用先初始化父类

使用super()在子类构造方法中第一行默认执行调用父类的构造方法

package edu.ffyc.javaOOP.extends_person;

public class Person { //父类是Object类
    private String name;
    private int age;

    //继承中的构造方法
    public Person(){
        System.out.println("Person类的无参构造方法");
    }
    public Person(String name){
        System.out.println("Person类的有参构造方法");
    }
}

package edu.ffyc.javaOOP.extends_person;

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.sql.SQLOutput;

public class Student extends Person{ //父类是Person类
    private String hobby;

    public Student(){
        System.out.println("Person类的无参构造方法");
    }
    public Student(String name){
        super(name);
        System.out.println("Person类的有参构造方法");
    }
}

package edu.ffyc.javaOOP.extends_person;

public class Zhang extends Student{ //父类是Student类
    String sex;

    public Zhang(){
        System.out.println("Person类的无参构造方法");
    }
    public Zhang(String name){
        super(name);
        System.out.println("Person类的有参构造方法");
    }

    public void work(){
        System.out.println("写代码使人秃头");
    }
}

package edu.ffyc.javaOOP.extends_person;

public class Test {
    public static void main(String[] args) {
        //调用自己的属性和方法
        Zhang zrx = new Zhang();
        zrx.sex = "男";
        System.out.println("性别:"+zrx.sex);
        zrx.work();
        Zhang zhang = new Zhang("小张");
    }
}

输出结果为

方法的重写:

原因:父类中的实现方式不能满足子类的需求

解决:在子类中对父类的方法进行重写(覆盖)

具体语法:

方法名,参数列表,返回值类型相同

访问权限修饰符不能小于父辈

@Override:添加此注解的标签表示此方法是从父类重写过来的会进行语法验证

package edu.ffyc.javaOOP.extends_person;

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.sql.SQLOutput;

public class Student extends Person{ //父类是Person类
    public void flag(){
        System.out.println("好好学习,天天向上");
    }
}

package edu.ffyc.javaOOP.extends_person;

public class Zhang extends Student{ //父类是Student类
    public void work(){
        System.out.println("写代码使人秃头");
        super.flag(); //调用父类中的flag方法
    }

    @Override //验证重写方法
    public void flag(){
        System.out.println("做一个码农");
    }
}

package edu.ffyc.javaOOP.extends_person;

public class Test {
    public static void main(String[] args) {
        Zhang zrx = new Zhang();
        zrx.work();
        zrx.flag(); //调用的是Zhang类中重写的flag方法
    }
}

抽象类(abstract)

概念:抽象类是一个类是抽象的即概念的

抽象方法:只有声明没有实现即没有实现体

public abstract void person(); //无实现体即为抽象方法 抽象方法需要用abstract修饰

注意事项:

①abstract修饰的方法是抽象的没有方法体

②在一些靠近顶层的类他的实现与大多数子类不同此时没有必要在顶层实现只需要声明功能即可

③如果一个类继承了抽象类要么重写抽象类中的所有抽象类要么将此类也设置为抽象类

抽象类:

①用abstract修饰抽象类中可能包含了抽象方法

②如果一个类中没有足够的信息(抽象方法)来描述一个具体的对象这样的类就是抽象类

③抽象类不能创建对象(因为其中包含了抽象方法) 其他功能与类相同(成员变量成员方法构造方法)

④抽象类一般位于体系结构的上层用来定义功能

有抽象方法的类必为抽象类

抽象类中可能包含抽象方法

package edu.ffyc.javaOOP.chouxiang;

public abstract class Abstract {
    String name;
    public abstract void race();
}

package edu.ffyc.javaOOP.chouxiang;

public class ZRX extends Abstract{
    public void race(){
        System.out.println(name+"是一个神灵");
    }
}

package edu.ffyc.javaOOP.chouxiang;

public class Test {
    public static void main(String[] args) {
        ZRX zrx = new ZRX();
        zrx.name = "小张";
        zrx.race();
    }
}

多态

概念:同一种事物在不同时刻有不同的表现不同的状态

条件:

①要有继承关系(类继承类类继承抽象类类实现接口)

②要有方法重写

③父类的引用指向子类对象

注意:

针对非静态成员方法:编译看左边运行看右边

针对静态方法成员变量:编译运行都看左边

优点:父类引用指向子类对象提升程序的扩展性

缺点:父类不能调用子类中特有的功能

解决:多态转型

多态转型

自动转型:子继承父(向上转型)

强制转型:向下转型(父类类型转为子类自己的类型)

//父类
package edu.ffyc.javaOOP.duotai;

public abstract class Person {
    String name;
    int age;
    public abstract void study();
}

//子类
package edu.ffyc.javaOOP.duotai;

public class Student extends Person{

    @Override
    public void study() {
        System.out.println(name+"热衷于敲代码");
    }

    //子类中特有的方法 多态无法自动转型(即多态的缺点)
    public void grade(){
        System.out.println(name+"的考试成绩为100分");
    }
}

//子类
package edu.ffyc.javaOOP.duotai;

public class Worker extends Person{
    @Override
    public void study() {
        System.out.println(name+"积极实现自己的价值");
    }
}

package edu.ffyc.javaOOP.duotai;
public class Test {
    public static void main(String[] args) {
        Person z = new Student(); //多态 父类的引用指向子类对象 自动转型
        z.name = "小张";
        z.age = 20;
        z.study();

        Student student = new Student();
        Worker worker = new Worker();
        student.name = "小新";
        worker.name = "小瑞";
        Test t = new Test();
        t.wishPerson(student);
        t.wishPerson(worker);
    }
    //多态 执行父类方法
    public void wishPerson(Person person){
        person.study();
    }

    //多态 执行子类中特有的方法
    public void willPerson(Person person){
        
        if(person instanceof Student){ //判断Person类(父类)中实际传入的类型是什么
            Student student = (Student)person; //强制转换 之后可调用子类中特有的方法
            student.study();
        }
    }
}

接口

生活中的接口:USB接口

接口:类似于抽象类可以看做是一个彻底的抽象类

接口和抽象类:都是用于在顶层类中指定规范(设计功能)

设计接口:

interface关键字

接口中没有构造方法

不能创建对象

规则:

一个接口可以继承多个窗口

一个类可以实现多个接口

一个类只能直接继承一个类

package edu.ffyc.javaOOP.jiekou;

public interface Person extends PersonA,PersonB{ //一个接口可以继承多个接口
    // public static final int age = 20; 成员变量默认为静态常量
    int age = 20;

    // public abstract void study(); 接口定义抽象方法
    void study();
    void eat(); 

    //静态方法 直接通过接口名调用
    public static void testStatic(){
        System.out.println("接口静态方法");
    }

    //默认方法 通过子类对象调用
    public default void testDefault(){
        System.out.println("接口默认方法");
    }
}

package edu.ffyc.javaOOP.jiekou;

public interface PersonA {
    void eat();
}

package edu.ffyc.javaOOP.jiekou;

public interface PersonB {
}

package edu.ffyc.javaOOP.jiekou;

public class Student implements Person{

    @Override
    public void study() {
        System.out.println("好好学习 天天向上");
    }

    @Override
    public void eat() {

    }
}

package edu.ffyc.javaOOP.jiekou;

public class Test {
    public static void main(String[] args) {
        Person person = new Student();
        person.study(); //抽象方法 通过对象调用
        Person.testStatic(); //静态方法 直接接口名调用
        person.testDefault(); //默认 通过对象调用
        System.out.println(Person.age); //接口中的常量
    }
}

final关键字

修饰类-------->该类不能被其他类继承
修饰方法------>该方法不能被重写
修饰属性------>该属性为常量创建时需要赋值赋值后值不能改变

package edu.ffyc.javaOOP.finaldemo;


public class Person {
// public class Person extends String{ 注意:String默认为final修饰 不能继承

    static final int a = 10; //定义之初进行赋值 之后所有对象不能改变其值 建议用static修饰

    final int b; //在定义之初没有赋值 那么必须在构造方法为其赋值
    public Person(int b){
        this.b = b;
    }
}

JAVA第四章

Java相关栏目本月热门文章