Java面向对象编程（上）

最新推荐文章于 2022-07-27 19:48:52 发布

王一宸

最新推荐文章于 2022-07-27 19:48:52 发布

阅读量103

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_44894173/article/details/112751323

版权

面向对象编程

Java的核心思想就是OOP
（以类的方式组织代码，以对象的形式封装（组织）数据）

初识面向对象

面向过程&面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二部做什么…
- 面向过程适合处理一些较为简单的问题。
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思考。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

面向对象

面向对象编程（Object-Oriented Programming，OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性
封装
继承
多态
从认识的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码的运行角度考虑是先有类后有对象。类是对象的模板。

回顾方法及加深

方法的定义
- 修饰符
- 返回类型
- break：跳出switch，结束循环
- return：结束方法，返回值
- 方法名：见名知意
- 参数列表：参数类型，参数名
- 异常调出
方法的调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字

package oop;

public class Student {
	//静态方法
	public void say() {
		System.out.println("我是一个学生");
	}
}


package oop;

public class StudentDemo {
	//静态方法   static
	public static void main(String[] args) {
		//实例化类
		Student student = new Student();
		student.say();
	}
	//和类一起加载的
    public static void a(){

    }
    //类实例化之后存在
    public void b(){

    }
}

package oop;

//值传递
public class Demo02 {
	public static void main(String[] args) {
		int a = 1;
		System.out.println(a);//1
		change(a);
		System.out.println(a);//1
	}
	
	//返回值为空
	public static void change(int a) {
		a = 10;
	}
}

package oop;

//引用传递：对象，本质还是值传递
//对象，内存
public class Demo03 {	
	public static void main(String[] args) {
		Person person = new Person();
		System.out.println(person.name);//null
		
		Demo03.change(person);
		System.out.println(person.name);//wyw
		
		
	}
	
	public static void change(Person person) {
		person.name = "wyw";
	}
}


class Person{
	String name;//null
}

类和对象的关系

类是一种抽象的数据类型，它是对某一事物整体描述/定义，但是并不能代表某一具体事物。
动物，植物，手机，电脑…
Person类，Pet类，Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例

创建与初始化对象

new关键字创建对象。
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：1.必须和类名相同 2.必须没有返回类型，也不能写void
构造器必须要掌握！

package oop02;

public class Student {
	//属性
	String name;
	int age;
	
	
	public void study() {
		System.out.println(this.name = "在学习");
	}
}


package oop02;

public class Application {
	public static void main(String[] args) {
		//类：抽象的，实例化
		//类实例化后会返回自己的对象
		Student student = new Student();
		
		student.name = "wyw";
		student.age = 20;
		
		System.out.println(student.name);
		System.out.println(student.age);
	}
}

构造器

package oop02;

public class Person {
	//一个类即使什么都不写，也会存在一个构造器
	//显式定义构造器
	String name;
	//实例化初始值
	//使用new关键字，本质是调用构造器
	public Person() {//无参构造
		
	}
	public Person(String name) {//有参构造
		this.name = name;
	}
	
	
	//Alt + Insert	快捷键
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
}

面向对象小结

类与对象：
类是模板，抽象
对象是具体的实例
方法：定义，调用。
对应的引用：
引用类型：对象是通过引用来操作的：栈->堆
对象的创建和使用
必须使用new关键字创建对象，构造器
类：
静态的属性属性
动态的行为方法

封装

该露的露，该藏的藏
要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装：
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
属性私有：getter/setter
优点：
1.提高程序安全性
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加

package oop03;

public class Student {
	private String name;
	private int id;
	private char sex;
	private int age;
	
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if (age>120||age<0){
            this.age = 3;
        }else{
            this.age = age;
        }

	}
	
}



package oop03;

public class Application {
	public static void main(String[] args) {
        Student student = new Student();
        student.setAge(999);//不合法
        student.setName("wyw");
        System.out.println(student.getName());
        System.out.println(student.getAge());
    }
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
Java中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该具有“is a”的关系。

package oop04;

//Person    人：父类
//在Java中所有的类都默认直接或间接继承Object类
public class Person {
	private int money = 10_0000_0000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void say() {
        System.out.println("说了一句话");
    }
}


package oop04;

//学生 is 人：派生类
//子类继承了父类就会拥有父类全部方法
public class Student extends Person{

}


/*
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
    }
}
 */

Object类
super
1.super调用父类的构造方法，必须在构造方法的第一行
2.super必须只能出现在子类的方法或者构造方法中！
3.super和this不能同时调用构造方法！
this
1.与super代表的对象不同
2.this是本身调用者这个对象，super是代表父类对象的引用
3.this没有继承也可以使用
4.super只能在继承条件下才能使用
5.this()：本类的构造
6.super()：父类的构造

package oop05;

public class Person {
	protected String name = "wyc";

    public Person() {
        System.out.println("Person无参执行");
    }

    public void print() {
        System.out.println("Person");
    }
}

package oop05;

public class Student extends Person{
	private String name = "wyw";
	
	 //隐藏代码，默认调用父类无参构造//Person无参执行
    public Student() {
        System.out.println("Student无参执行");//Student无参执行
        System.out.println("=======================");
    }
    
    public void test(String name) {	
        System.out.println(name);//Hello
        System.out.println(this.name);//wyw
        System.out.println(super.name);//wyc
        System.out.println("=======================");
    }
    
    public void test1() {
        print();//Student
        this.print();//Student
        super.print();//Person
        System.out.println("=======================");
    }

    public void print() {
        System.out.println("Student");
    }
}

package oop05;

public class Application {
	 public static void main(String[] args) {
	        Student student = new Student();
	        student.test("Hello");
	        student.test1();
	    }
}

方法重写：
1.不重写：无@override

//重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B-->test()");
    }
}

public class A extends B {
    public  void test(){
        System.out.println("A-->test()");
    }
}

public class Application {
    public static void main(String[] args) {
        //方法的调用只和定义的数据类型有关
        A a = new A();
        a.test();//A-->test()

        //父类的引用指向子类
        B b = new A();
        b.test();//B-->test()
    }
}

2.重写：有@override

public class B {
    public  void test(){
        System.out.println("B-->test()");
    }
}

public class A extends B {
    @Override//注解，重写
    public void test() {
        System.out.println("A-->test()");
    }
}

public class Application {
    //静态方法：方法的调用只和定义的数据类型有关
    //非静态方法：重写
    public static void main(String[] args) {
        //方法的调用只和定义的数据类型有关
        A a = new A();
        a.test();//A-->test()

        //父类的引用指向子类
        B b = new A();//子类重写了父类的方法
        b.test();//A-->test()
    }
}

重写：需要有继承关系，子类重写父类的方法！

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大：public > protected > default > private
抛出的异常的重写：范围，可以被缩小，但不能扩大：ClassNotFoundException > Exception(大)
方法体不同

为什么需要重写：
父类的功能子类不一定需要，或者不一定满足。

王一宸

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java面向对象编程（上）

面向对象编程Java的核心思想就是OOP（以类的方式组织代码，以对象的形式封装（组织）数据）初识面向对象面向过程&面向对象面向过程思想步骤清晰简单，第一步做什么，第二部做什么…面向过程适合处理一些较为简单的问题。面向对象思想物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思考。面向对象适合处理复杂的问题，适合处理需要多人协作的问题。对于描述复杂的事物，为了从宏观上把握、从整体上
复制链接

扫一扫