本文介绍了面向对象编程的基本概念，包括类与对象的构建、构造器的使用、封装、继承、多态等核心概念，并通过Java代码示例详细解释了这些概念在实际编程中的应用。同时，文章还探讨了static关键字的作用、抽象类和接口在设计中的重要性。
文章目录
1.面向过程 & 面向对象
-
面向过程思想
-
步骤清晰简单，第一步做什么，第二步做什么…
-
面对过程适合处理一些较为简单的问题
-
-
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索面向对象适合处理复杂的问题，适合处理需要多人协作的问题!
- 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理
2.什么是面向对象
- 面向对象编程（Object-Orirented Programming,OOP）
- 面向对象编程的实质就是：以类的方式组织代码，以对象的组织（封装数据）。
- 面向对象最大的特点是抽象
- 三大特性：
- 封装
- 继承
- 多态
- 从认知论的角度考虑是先有对象后有类。对象是具体的事物，而类是抽象的，是对对象这个群体进行一个抽象概括统一。
- 从代码的运行角度考虑是先有类后有对象。类是对象的一个模板。
3.回顾方法及加深
-
方法的定义
- 修饰符
- 返回类型
- break: 跳出switch，结束循环 和 return 的区别
- 方法名:注意规范就OK 见名知意
- 参数列表: (参数类型，参数名) …
- 异常抛出:
-
方法的调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传
- this关键字
-
package oop.Demo01; //Aprick类 public class Aprick { //main方法 public static void main(String[] args) { //静态方法 static,可直接调用方法名 //非静态方法吧，要实例化这个类 Aprick aprick = new Aprick(); String s = aprick.say_hello(); System.out.println(s); s(); } /* * 方法的定义： * 修饰符 返回类型 方法名(...){ * 方法体 * 返回值 return:方法结束； * }*/ public String say_hello(){ return "hello!!!"; } public static void s(){ return; } public int max(int a,int b){ return a>b ?a:b;//三元运算符 } } -
package oop; //类 Demo01 public class Demo01 { //main方法 public static void main(String[] args) { /* * 方法调用 * 静态方法 static * 动态方法 */ Demo02.name(); // 实例化这个类 new // 对象类型 对象名 = 对象值 Demo02 demo02 = new Demo02(); demo02.age(); } } //类 Demo02 public class Demo02 { //div one 静态方法 static public static void name(){ System.out.println("hhhh"); } public void age(){ System.out.println("11111"); } } -
package oop; public class Demo03 { //值传递（java是值传递） public static void main(String[] args) { int i =19; //非静态方法 ->实例化this类 -> 调用 Demo03 demo03 = new Demo03(); int a = demo03.age(i); System.out.println(a);//100 Demo03.change(i); System.out.println(i);//19 } public int age(int a){ a=100; return a; } public static void change(int b){ b=108; } } -
package oop; //引用传递：对象；但实质也是值传递 public class Demo04 { public static void main(String[] args) { // 调用非静态方法 ->实例化this类 -> 调用 Person person = new Person(); System.out.println(person.name);//null //调用静态方法 Demo04.change(person); System.out.println(person.name);//漫卿 } public static void change(Person person){ // person 是一个对象：指向的-->Person person = new Person() 可以改变属性！！！ person.name="漫卿"; } } // 定义一个类: Person,定义了一个属性：name class Person { String name;//null }
4.类与对象的构建
- 创建与初始化对象
- 使用new关键字创建对象
除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化使用new关键字创建的时候，以及对类中构造器的调用
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩
个特点:- 必须和类的名字相同
- 必须没有返回类型也不能写void
构造器必须要掌握
// Application 一个项目应该只存在一个main方法
package oop;
// div 学生类
public class Student {
// 属性:字段
String name;//null
int age;//0
// 方法
public void study(){
System.out.println(this.name+"在学习");
}
}
System.out.println("+++++++++++++++++");
// 使用new关键字构造对象
public class Application {
// Application 一个项目应该只存在一个main方法
public static void main(String[] args) {
// 类：抽象的，需要实例化new
// 类实例化后会返回一个自己的对象！！！
// student对象就是Student类的一个具体事例
//Student student = new Student();
Student xiMing = new Student();
Student xiHong = new Student();
// 对创建好的对象默认初始化
System.out.println(xiMing.name);
System.out.println(xiMing.age);
//
xiHong.name="西红";
xiHong.age=55;
System.out.println(xiHong.name);
System.out.println(xiHong.age);
}
}
5.构造器
构造器：
-
和类名相同
-
没有返回值
作用:
1.new 本质在源用为造方法2. 胡始化对象的值生言店
1，定义有参构益之后，如界想使用无零前谑，显示的定义一个无参的规道
Alt + Insert
this.=
作用：
- new本质在调用构造方法
- 初始化对象的值
注意点：
- 定义有参构造之后，如果想使用无参构造，必须显示定义一个无参构造
- 快捷键：Alt+insert
package oop.Demo03;
public class Person {
// 一个类即使什么都不写，它也会存在一个方法
// 显示定义的构造器
String name;//null
// 1.使用new关键字，本质是在调用构造器
// 2.用于初始化值
// 3.Alt+insert可自动生成有无参构造
// 无参构造
public Person(){
this.name="xiaomi";
}
// 有参构造:一旦定义了有参构造，就必须定义无参构造
public Person(String name){
this.name=name;
}
}
package oop.Demo03;
public class Application {
public static void main(String[] args) {
// new一个实例对象
Person person = new Person();
System.out.println(person.name);
Person person1 = new Person("xiaoming");
System.out.println(person1.name);
}
}
6.封装
1.我们程序追求高内聚，低耦合
- 高内聚就是类的内部数据操作细节自己完成，外界无权干涉
- 低耦合就是尽量暴露少量的方法给外部
-
百度相关地址：https://baike.baidu.com/item/%E9%AB%98%E5%86%85%E8%81%9A%E4%BD%8E%E8%80%A6%E5%90%88/5227009?fr=aladdin
package oop.Demo04;
// 封装
public class Student {
// 定义属性私有
private String name;
private int age;
private int grade;
// 提供一些可以操作这个属性的方法
// 提供一些 public的 get/ set方法
// get 获取数据
public String getName() {
return name;
}
// set 为数据赋值
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
//封装可对数据进行校验
if (age>120||age<0){
this.age = -1; //标记数据不合法
}else{
this.age = age;
}
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
}
public class Application {
/*封装的作用
* 1.提高程序的安全性，保护数据
* 2.隐藏代码的实现细节
* 3.统一接口
* 4.系统可维护性添加
* */
public static void main(String[] args) {
Student student = new Student();
student.setName("小明");
student.setAge(230);
student.setGrade(520);
System.out.println(student.getName());
System.out.println(student.getAge());
System.out.println(student.getGrade());
}
}
7.继承
- 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
- extends的意思是"扩展"，子类对父类的扩展
- Java中只有单继承，没有多继承，但接口可以实现多继承！
- 继承是类与类之间的一种关系，类与类之间的关系还有依赖、组合、聚合等。
-
package oop.Demo05; //人：父类 // 子类可继承父类的所有public方法 /* public 公共类 protected 受保护类 default 默认类 private 私有类 * */ public class Person { String surname="张"; public void print(){ System.out.println("父类:Person"); } private int knowledge = 10000; public int getKnowledge() { return knowledge; } public void setKnowledge(int knowledge) { this.knowledge = knowledge; } } //学生 is person：子类（派生类） public class Student extends Person { String name="三"; } //老师 is person：子类（派生类） public class Teacher extends Person { } public class Application { public static void main(String[] args) { Student student = new Student(); student.print(); //父类:Person System.out.println(student.surname+student.name); //张三 student.setKnowledge(100); System.out.println(student.getKnowledge()); } } -
object类
快捷键：Ctrl+h
-
super – this
package oop.Demo05;
//人：父类
public class Person {
public Person() {
System.out.println("父类无参构造执行了");
}
}
//学生 is person：子类（派生类）
public class Student extends Person {
String name="三";
public Student() {
//隐藏代码：调用了父类的无参构造
super();//调用父类的无参构造,必须在子类构造器的第一行
System.out.println("子类无参构造执行了");
}
}
public class Application {
public static void main(String[] args) {
new Student();
}
}
super 注意点：
-
super调用父类的构造方法，必须在构造方法的第一个
-
super 必须只能出现在子类的方法或者构造方法中!
-
super和 this 不能同时调用构造方法!
-
与this的比较：代表的对象不同:
- this: 本身调用者这个对象
- super：代表父类对象的应用
- 前提：
- this：没有继承的时候也能使用
- super:只能在继承条件才可以使用
- this：本类的构造
- super:父类的构造
-
方法重写
package oop.Demo05;
// A继承B
public class A extends B{
@Override // 子类对父类的重写
public void test() {
System.out.println("A=>test");
}
}
// 重写都是方法的重写，与属性无关。
public class B {
public void test(){
System.out.println("B=>test");
}
}
public class Application {
public static void main(String[] args) {
// 静态方法的调用只与最左边的定义的数据类型有关
// 静态方法与非静态方法的区别很大
//非静态方法：重写
A a = new A();
a.test();
// 父类的调用都指向了子类
B b = new A();
b.test();
}
}
8.多态
多态注意事项:
-
多态是方法的多态，属性没有多态!
-
父类和子类，有联系，类型转换异常！CLassCastException !
-
存在条件: 继承关系，方法需要重写，文类引用指向子类对象！Father f1 = new Son();
-
不能重写的类型：
- static 方法，属于类，它不属于实例
- final 常量
- private方法;
-
instanceof (类型转换) 引用类型，判断一个对象是什么类型；判断两个类之间是否存在父子关系
package oop.Demo06; public class Application { public static void main(String[] args) { // Object > String // Object > Person>Teacher // Object > Person>Student Person person = new Student(); System.out.println(person instanceof Object); // true System.out.println(person instanceof Person); // true System.out.println(person instanceof Student); // true System.out.println(person instanceof Teacher); // false Student student = (Student) person; // 父类强制转换为子类 student.eat(); } } /* 1.父类的引用指向子类的对象 2.把子类转换成父类，向上转型 3.把父类转换成子类，向下转型，强制转换 4.方便方法的调用，减少重复代码，简洁
*/
package oop.Demo06;
public class Application {
public static void main(String[] args) {
// 一个对象的实际类型是确定的
new Student();
new Person();
// 可以指向的引用类型是不确定的
Student s1 = new Student();
Person s2 = new Student(); //父类的引用指向了子类
Object s3 = new Student();
s1.run(); // Student类能调用的方法都是自己或者父类的
s2.run(); // 对象能调用哪些方法,主要看左边的类型,与右边关系不大
s1.eat();
//s2.eat(); // 父类可以指向子类,但不能调用子类独有的方法
}
}
9.static关键字详解
-
package oop.Demo07; // static public class Teacher { private static int age; // 静态的变量，多线程 private int score; // 非静态的变量 public static int getAge() { Teacher teacher = new Teacher(); // 静态方法可以直接调用静态方法，但是不能直接调用非静态对象，需要用实例化对象调用 teacher.getScore(); setAge(10); return age; } public static void setAge(int age) { Teacher.age = age; } public int getScore() { // 非静态方法可以直接调用其他所有的静态方法，也可以直接调用非静态对象 getAge(); setScore(100); return score; } public void setScore(int score) { this.score = score; } public static void main(String[] args) { Teacher t1 = new Teacher(); setAge(30); System.out.println(Teacher.age); // 推荐使用类直接调用静态属性 System.out.println(t1.age); System.out.println(t1.score); } } -
package oop.Demo07; public class Student { // 2. 赋初值 { System.out.println("匿名代码块"); } // 1.static 只执行一次 static { System.out.println("静态代码块"); } // 3. public Student() { System.out.println("构造方法"); } public static void main(String[] args) { Student s1 = new Student(); //静态代码块 --> 匿名代码块 --> 构造方法 System.out.println("+++======++++"); Student s2 = new Student(); //匿名代码块 --> 构造方法 } } -
package oop.Demo07; // 静态导入包 import static java.lang.Math.*; public class Person { public static void main(String[] args) { System.out.println(random()); // 产生随机数 System.out.println(PI); } }
10.抽象类
-
package oop.Demo08; // abstract 抽象类：类，单继承；接口实现多继承 public abstract class Action { // 约束，让别人帮我们实现方法 // abstract:抽象方法，只有方法名字，没有方法实现 public abstract void doSomething(); /* * 1.不能new这个抽象类，只能靠子类去女:现它:约束! * 2.抽象类中可以写普通的方法~ * 3.抽象方法必须在抽象类中~ * 抽象的抽象: 约束~ * 思考题? * 不能new抽象类,那么存在构造器么? * 存在的意义 抽象出来~ 提高开发效率 */ } -
package oop.Demo08; // 继承抽象类，必须实现方法，否则会报错，除非这个类也是 abstract public class A extends Action{ @Override public void doSomething() { System.out.println("flying"); } }
11.接口
- 普通类:只有具体实现
- 抽象类:具体实现和规范(抽象方法)都有!
- 接口: 只有规范!自己无法写方法~专业的约束! 约束和实现分离: 面向接口编程~
package oop.Demo09;
//interface 定义的关键字，接口都需要实现类
public interface Student {
// 接口中只能定义方法，不能实现方法，也不能被实例化
// 接口中所有定义的方法都是抽象的 public abstract
void add(String name);
void delete(String name);
void query(String name);
void update(String name);
int age = 0; // 常量public static final
}
public interface User {
void timer(String time);
}
// 类可以实现接口implements
// 利用接口实现多继承
public class UserServiceImpl implements Student, User {
//重写方法 快捷键 alt+F12
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void query(String name) {
}
@Override
public void update(String name) {
}
@Override
public void timer(String time) {
}
}
// 接口中只能定义方法，不能实现方法，也不能被实例化
// 接口中所有定义的方法都是抽象的 public abstract
void add(String name);
void delete(String name);
void query(String name);
void update(String name);
int age = 0; // 常量public static final
public interface User {
void timer(String time);
}
// 类可以实现接口implements
// 利用接口实现多继承
public class UserServiceImpl implements Student, User {
//重写方法 快捷键 alt+F12
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void query(String name) {
}
@Override
public void update(String name) {
}
@Override
public void timer(String time) {
}
}
扫一扫
1047
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
