本文介绍了面向对象编程的基本概念，包括类与对象的定义、属性和方法，以及如何通过构造器创建实例。此外，讲解了封装的概念，强调隐藏内部实现细节并提供公共接口的重要性。还探讨了继承的特性，如子类继承父类的非私有属性和方法，以及构造器的初始化顺序。最后，提到了抽象类和接口在多态中的作用，以及它们在Java编程中的应用。
一、面向对象(类和对象)
面向对象的世界里面，所有东西都是一个对象。世界就是由对象组成。
面向过程：类似流程，需要自己去完成
面向对象：创建合适的对象，由对象来帮我们完成各种事情
使用软件就是为了解决现实生活中的问题，现实生活又是由对象组成，用面向对象的思想去描述这个面向对象的世界，更加的容易理解和方便。
二、类
1.1 创建类
- 类是一个模板，通过对象抽象出来的
- 一个类可以创建任意多个对象，按需去创建（
new关键字）
类的组成：
- 1）属性
- 2）方法
- 3）构造器/构造方法
关键字：class
public class Dog{
//属性
}
1.2 属性
称为成员变量，全局变量，特征
public class Dog {
//步骤二：发现属性（每个对象都有自己的属性，存放的都是我们关注的属性）
//属性：成员变量|全局变量|特征
//回顾：变量的内容 语法: 数据类型 变量名 = [初始值]
//全局变量特点：1）可以不赋初始值，自动默认值 2）全局变量可以使用访问修饰符 3）位置在类里面，方法外面
//假设狗属性：品种，有几条腿，身高体重，毛发颜色
String type = "中华田园犬";
int legs; //可以不给初始值，默认就是对应数据类型的默认值， int:0
String height;
String weight;
String color = "黄毛";
}
1.3 行为|方法(函数)
java中一般称为方法
语法：
语法格式： [<修饰符>] <返回类型> <方法名>([< 参数表>]) { [< 语句>] } 说明： 修饰符：public,private,protected 等。 返回类型：return语句传递返回值。没有返回值：void。 //案例:方法功能，计算两个数的和，并且返回给方法的调用者 public int add(int num1,int num2){ int result = num1+num2; return result; }组成方法的四要素：
返回值类型
1）没有返回值，必须使用
void关键字。表示该方法不需要给调用返回内容2）有返回值：方法体的最后，一定使用
return关键字//有返回值 public int add(int num1,int num2){ int result = num1+num2; return result; } //没有返回值 public void println(String msg){ System.out.println("需要打印的内容："+msg); }方法名称
- 1）符合标识符的命名规则
- 2）符合标识符的命名规范，小驼峰，见名知意
- 3）重复重载，重复重写 方法的名称相同（后面讲）
形参列表
- 1）形参列表可以为空，形参列表其实是一个
局部变量，只能在该方法中使用- 2）方法调用时候，传入的参数，叫做
实际参数，简称实参方法体
- 1）就是该方法的具体功能，这个也是以后我们开发的主要阵地
- 2）一个方法，可以看出是一个功能
//需求：该方法主要负责打印 就阔以了
public void println() {
System.out.println("type = " + type + ", 腿：" + legs + " ,身高：" + height + " ,体重：" + weight + " ,颜色：" + color);
}
/**
* 需求：看门，抓小偷
*
* @param name :我们需要抓的人
* @return 返回在什么时间，抓了谁？
*/
public String look(String name) {
String result = "在:" + System.currentTimeMillis() + ",抓了：" + name;
return result;
}
/**
* 需求：小狗是否睡着了
* @return true:睡着了 false:没有睡着
*/
public boolean sleep(){
return false;
}
1.4 构造方法/构造器
1、构造方法特征
- 1）构造方法的名称，必须要和类名保持一致（注意：普通方法名也可以类名）
- 2）构造方法没有返回值，同时也不许要使用
void关键字，如果使用void表示该方法就不是一个构造方法 - 3）每个类都有一个默认无参的构造方法，不去定义，也可以使用
new XXX() - 4）如果定义了有参构造，那么无参构造就会自动的消失，如果还需要无参构造，就需要额外显示定义
2、构造方法作用
很多东西构造方法也可以用，普通方法也可以用。
区分：
构造方法主要作用：
- 1）构造方法 每次
new关键字以后，都会自动被调用。 - 2）主要作用，就是在创建对象的同时，给对象的属性进行初始化操作
3、调用构造方法
必须通过new关键字去调用
public Dog(String t, String n) {
type = t;
name = n;
}
public Dog() {
type = "中华田园犬";
legs = 4;
height = "80cm";
weight = "20kg";
color = "黄毛";
name = "来福";
}
调用：
Dog dog1 = new Dog(); //调用无参构造方法
Dog dog2 = new Dog("泰迪","旺财");
三、对象
使用 new +构造方法 创建一个新的对象；
使用 “对象名.对象成员” 的方式访问对象成员（包括属性和方法）
3.1 简介
- 类是对象的抽象，是一个默认
- 对象是类的具体体现，实实在在存在的东西
- 如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y5OGn5sp-1646137743458)(笔记_images/1645759413415.png)]
public static void main(String[] args) {
//创建对象
Dog dog1 = new Dog("泰迪", "旺财");
Dog dog2 = new Dog("拉布拉多犬", "来福");
System.out.println("dog1 = " + dog1.name);
System.out.println("dog2 = " + dog2.name);
System.out.println("dog1 = " + dog1.name);
//使用对象
//1)对象名.属性名
dog1.name = "小黑"; //赋值
dog1.color = "黑色";
//2)对象名.方法名
dog1.println(); //没有返回值 所以不能使用变量去接收
String look = dog1.look("法外狂徒");//有返回值
boolean sleep = dog1.sleep();//有返回值
System.out.println("look = " + look);
System.out.println("sleep = " + sleep);
}
四、封装简介
回顾：
-
类和对象
-
类：
- 1）类是一个模板
- 2）是通过对象抽象出来的
- 3）类是一组具有相同属性或者行为的对象的集合
- 4）关键字：
class
-
对象：
- 1）类的具体体现
- 2）万物皆对象
- 3）对象的关键字：
new
-
类的组成
-
1）属性 ：成员变量、全局变量
-
2）方法 ：其实是一个功能块
-
掌握方法的四要素
-
1、返回值类型 2、方法名称 3、形参列表 4、方法体
-
//有返回值 public int add(int num1,int num2){ return num1+num2; } //没有返回值 public void println(String msg){ System.out.println(msg); }
-
-
3）构造器/构造方法
- 1）构造方法的名称必须和类名一致
- 2）构造方法没有返回值，也不需要使用
void关键字 - 3）每个类都默认有一个无参的构造方法，所以说可以直接通过无参构造去创建对象
new Person() - 4）如果定义了有参构造，那么无参构造就会消失
- 5）构造也支持方法的
重载，重载就是同名不同参数
-
1.1 什么是封装
面向对象的三大特征：
- 封装：隐藏内部实现细节，对外提供一个可访问的入口（就是把属性私有化，提供公共的get/set方法）
- 继承：子类自动的享有父类中所有的非私有属性和方法
- 多态：同一事物，具有多种形态
- 抽象（四大特征）：只管定义，不管具体的实现。例如抽象方法，没有方法体。
1.2 封装的主要作用
- 使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题
- 将属性进行隐藏，同时提供get/set方法来操作数据
1.3 访问修饰符
java中总共提供了4中访问修饰符：
- private ：私有的
- protected ：受保护
- 默认 ：缺省默认
- public ：公共
范围：
| 级别 | 同一类 | 同包 | 子类 | 所有 |
|---|---|---|---|---|
| private | 支持 | 不支持 | 不支持 | 不支持 |
| 默认 | 支持 | 支持 | 不支持 | 不支持 |
| protected | 支持 | 支持 | 支持 | 不支持 |
| public | 支持 | 支持 | 支持 | 支持 |
1.4 方法重载
- 重载就是在同一个类中允许同时存在一个以上的同名函数
- 参数必须不同：参数个数、参数类型、参数的顺序至少一个不同
- 重载方法的返回值类型可以相同，也可以不同
- 调用时根据方法的参数类型来区别。
- 构造方法也支持重载
//笔试题，选择题
public class Dog{
public int age;
public Dog(){
age = 10;
}
}
public static void main(String args[]){
Dog dog = new Dog();
System.out.println(dog.age); //0
}
五、继承
5.1 简介
- 子类会自动的享有父类中所有的非私有属性和方法
- 关键字：
extends,核心语法：class 子类 extends 父类 - 子类的功能，比父类的功能会更多
- Object是所有类直接或者间接的父类，是老祖宗
- 所有类如果没有显示的去使用
extends关键字，那么默认继承的就是Object类 - Java语言的继承是单继承的，一个类只能直接继承一个父类
- 子类和父类都是一个相对的关系
5.2 继承优点
5.3 哪些不能被继承
- 私有的属性和方法
- 构造方法不能被继承
- 子类与父类不在同包，使用默认访问权限的成员
5.4 构造方法初始化顺序
5.5 方法的重写
- 子类继承父类的方法，并重写。有方法重写的地方都有继承关系
- 方法的重写，同名同参同返回值
- 可以通过
@Override判断一个方法是否是重写方法 - 子类也可以存在重载的关系
- 覆盖方法不能使用比被覆盖方法更严格的访问权限
@Override
public String getInfo() {
return super.getInfo() + " ,school =" + school;
}
重载和重写的区别：
- 1）重载同名不同参，重写是同名并且同参
- 2）重写只能子类重写父类中的方法，可以重载本类中的方法，也可以重载父类中的方法
- 3）构造方法可以重载，但是构造方法不能重写
六、关键字
6.1 super
super关键字表示对象的父类的对象，主要有三种使用方式：
第一种：调用父类中的构造方法
//父类
public class Animal {
//父类的无参构造消失了
public Animal(String n) {
name = n;
System.out.println("animal 父类构造方法..." + name);
}
public Animal(String n, int a) {
name = n;
age = a;
System.out.println("n = " + n + ", a = " + a);
}
}
//子类
public class Dog extends Animal {
public Dog() {
//super:关键字
//super(); //默认都会调用无参构造
//super调用指定构造方法
//super("小王");
super("小花", 123);
System.out.println("dog...构造方法" + color);
}
}
第二种：调用父类中属性
public void show() {
System.out.println("super.name = " + super.name);
}
第三种：调用父类中方法
public String getInfo() {
return super.getInfo() + " ,school =" + school;
}
6.2 this
this关键字表示当前对象，主要有三种使用方式：
第一种：调用本类中的构造方法
public Dog(String n) {
this(n, 18);
}
public Dog(String n, int a) {
super(n, a);
}
6.3 instanceof
-
判断某一个对象，是否属于某一个类型
-
x instanceof A：检验x是否为类A的对象，返回值为boolean型
-
if (person instanceof Teacher) { Teacher teacher = (Teacher) person; teacher.work(); }
第二种：调用本类中属性
public void show() {
//this默认存在
System.out.println("name = " + name);
System.out.println("this.name = " + this.name);
}
6.4 final
表示最终的，一旦被final修饰就不能发生改变
final可以修饰哪些内容？
- 变量：变成了常量 1）证明值不能被修改 2）必须赋初始值
- 方法：表示最终方法，该方法不能被
重写 - 类：最终类，该类不能被继承
- 面试题：
String字符类能不能被继承？
- 面试题：
6.5 static
静态的，属于类级别的 1）优先级级别高 2）所有的对象共用 3）直接使用类名调用，不用对象名
- 变量: 多个对象都是共用
- 方法:类加载的时候，就已经完成了，不需要依赖于对象。类名.方法名()
- 代码块: 静态代码块，只会执行一次。优先级很高
class Dog extends Animal {
public Dog() {
System.out.println("子类构造方法...Dog.Dog");
}
// 代码块
{
System.out.println("子类的普通代码块....");
}
static {
System.out.println("子类的静态代码块....");
}
}
七、多态
7.1 多态简介
- 同一事物，具有多种形态。例如：对面来了一只狗，对面来了一只动物；
- 具体体现形式：
- 父类的引用指向子类的对象；
Person person = new Student(); - 方法的重载和方法的重写，方法的名称一致，但是具体的实现内容不同。
- 父类的引用指向子类的对象；
八、Object类
8.1 简介
- Object是所有类的父类
- 如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类
8.2 Object常用方法
Object提供了很多方法，可以直接使用。
Object这些方法很多都是本地方法，直接用C语言实现的，被native修饰。无法在进一步查看源码
public native int hashCode();
- equals()
- toString()
1、equals()
源码：最原始的equals()方法和 == 作用是一样的，都是用来对象的地址是否相同。
public boolean equals(Object obj) {
return (this == obj);
}
- equals()方法是Object类的方法，由于所有类都继承Object类，也就继承了equals()方法。只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。格式:obj1.equals(obj2)
- 当用equals()方法进行比较时，对类File、String、Date及封装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象
- 原因：这几个类帮我们重写了equals()方法，所有用的就不再是Object最原始的方法了
- 根据需要去重写equals方法。
@Override
public boolean equals(Object o) {
//this = p1
if (this == o) return true; //自己和自己比
//p1.equals("xxx");
if (o instanceof Person) {
//person 和 person 比，比较name和age属性
Person p1 = (Person) o;
if (this.name.equals(p1.name) && this.age == p1.age) {
return true; //全相等
}
}
return false;
}
2、toString()
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
- 负责打印对应的信息，默认打印：类的名称+@+内存地址 ==>
com.hzit.day09.demo04.Person@71bc1ae4 - 在进行String与其它类型数据的连接操作时，自动调用toString()方法
- 可以根据需要在用户自定义类型中重写toString()方法
@Override
public String toString() {
return "Person-xxxxx{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
九、抽象类和接口
9.1 简介
- abstract修饰的类表示抽象类。
- abstract修饰的方法表示抽象方法
- 抽象类可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类。
- 子类继承了抽象类，那么子类必须实现父类的抽象方法，否则子类也要被定义为抽象的。
- 抽象类既可以包含普通方法，也可以包含抽象方法
package com.hzit.day09.demo05;
/**
* 员工
*/
public abstract class Emp {
public Emp() {
System.out.println("抽象类的构造方法...");
}
private String name;
private int age;
public abstract void work();
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;
}
}
class Manage extends Emp {
public Manage() {
System.out.println("Manage.Manage");
}
@Override
public void work() {
System.out.println("经理正在吹牛....");
}
}
class Demo05 {
public static void main(String[] args) {
//Emp manage = new Manage();
//manage.work();
}
}
9.2 接口
- 也可以看做是特殊的抽象类，接口中的方法都是抽象方法(jdk1.8新增了默认方法和静态方法)
- 接口中的变量，只能是静态常量
public static final - 关键字:
interface - 接口可以继承接口，支持多继承
- 类继承类，只能单继承
- 类实现接口，支持多实现
implements
- 接口更多的是定义一种规范，不管具体的实现。
- 实现类实现接口，必须要实现接口中所有方法
package com.hzit.day09.demo06;
public class Demo06 {
}
class Person implements Action, C {
@Override
public void sleep() {
}
@Override
public void eat() {
}
@Override
public void run() {
}
@Override
public void cc() {
}
}
/**
* 接口可以继承接口，支持多继承
*/
interface Action extends A, B {
//自动添加：public static final
public static final String name = "xxx";
void sleep();
}
interface A {
//默认给方法添加： public abstract
public abstract void eat();
}
interface B {
public abstract void run();
}
interface C {
public void cc();
}
9.3 接口和抽象类的区别
- 抽象类中，可以有抽象方法也可以有普通方法，接口全部都是抽象方法，不能有普通方法
- 抽象类中有变量，但是接口中都是静态常量
- 抽象类只能单继承，接口可以多实现
- 子类通过implements关键字实现接口，子类通过extends关键字继承抽象类。
- 接口是一个特殊的抽象类
扫一扫
340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
