本文详细介绍了面向对象编程的核心概念，包括类、对象、构造器、封装、继承和多态。通过实例展示了如何创建类、定义构造器以及如何进行方法重写。强调了封装的重要性，指出其目的是实现“高内聚，低耦合”。此外，还讨论了多态的特性及其在实际编程中的应用。最后提到了抽象类和接口在约束和规范代码方面的作用。
面对对象编程
面对对象的本质就是：以类的方式组织代码，以对象的组织（封装）数据
类是一种抽象的数据类型它对某一事物整体描述、定义，但是并不代表某一个具体的事物
例如 ： 人 狗 车
对象是抽象概念的具体实例
例如：张三 旺财 大黄蜂
类的构造器也称之为构造方法，是在进行创建对象时必须调用的，构造器的特点
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
public class Person {
//一个类即使什么都不写 也会存在一个方法
//显示的定义构造器
String name;
int age;
//1.使用new关键词，本质是调用构造器
//2.实例化初始值
public Person(){
}
//有参构造，一旦定义了有参构造，无参就必须显式定义
public Person(String name){
this.name=name;
}
public Person(int age) {
this.age = age;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
/*
public static void main(String[] args) {
// new 实例化了一个对象
Person person = new Person();
System.out.println(person);
}
构造器特点 1.与类名相同
2.没有返回类型和返回值
作用 1.初始化对象的值
2.new 本质是调用构造器
注意点：一旦有了有参构造，无参就必须显示定义
Alt + insert 快捷键 或者 鼠标点击右键 Generate
*/
封装 继承 多态
封装 : 属性私有，get/set
该漏的漏，该藏得藏 我们程序设计要追求 : “高内聚，低耦合”
-
高内聚：内部数据操作细节自己完成，不允许外部干涉
-
低耦合：近暴漏少量的方法给外部使用
//设置私有属性值 private String name; private int id; //提供一些可以操作这个属性值的方法 //提供一些public的set，get方法 //get获得这个数据 public String getName() { return this.name; } //set 给这个数据设置值 public void setName(String name) { this.name = name; } public int getId() { return id; } public void setId(int id) { this.id = id; } //1.提高代码的安全性，私有性 //2.隐藏代码实现细节 //3.统一接口 //4.增加了系统的可维护性
继承
extends的意思是“扩展”。子类是父类的扩展
java中只有单继承，没有多继承
在Java中，所有的类全部都直接或者间接的继承object类
Ctrl+h 查看继承列表
public int money = 1_000_0000;
public void say(){
System.out.println("他说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
/*
public class Aeard extends Person01{
}
*/
/*
public static void main(String[] args) {
Aeard aeard = new Aeard();
System.out.println(aeard.money);//100000000
aeard.say();//他说了一句话
}
*/
super注意点
- super调用父类构造方法，必须在构造方法第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this 不能同时调用构造方法
vs this
代表对象不同
this ： 本身调用者这个对象
super ： 代表父类对象的应用
前提：this 没有继承也可以使用
super：只能在继承条件下才可以使用
构造方法：this();本类的构造
super():父类的构造！
方法的重写
重写都是方法的重写，和属性无关
public class A extends B{
public void Test(){
System.out.println("holle");
}
}
public class B {
public void Test(){
System.out.println("word");
}
public class Application {
public static void main(String[] args) {
//静态方法和非静态方法区别很大
//静态方法: 方法的调用只和做边，定义的数无关
//非静态：重写
A a = new A();
a.Test();
//父类的引用指向了子类
B b = new A();//子类重写了父类的方法
b.Test();
}
}
重写：需要有继承关系，子类重写父类的方法！
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大，但不能缩小。public》protected》Default》private
4. 抛出的异常：范围，可以被缩小，不能被放大
重写，子类的方法的父类的方法必须要一致，方法体不同！
为什么要重新：
- 父类的功能，子类不一定需要，或者不一定满足！
多态
public class A extends B{
@Override
public void run() {
System.out.println("row");
}
public void eat(){
System.out.println("rice");
}
}
public class B {
public void run(){
System.out.println("run");
}
}
public class Application {
public static void main(String[] args) {
//父类指向子类
// A类型 能调用的方法都是自己或者继承父类的
A a = new A();
// B类型 父类型，可以指向子类，但无法调用子类独有的方法
B b = new A();
Object c = new A();
a.run();//row
b.run();//row
//对象能执行哪些方法，主要看左边的类型 和右边的关系不大
a.eat();
((A) b).eat();
}
}
####多态注意事项：
-
多态是方法的多态，属性没有多态
-
父类和子类，有联系，类型转换异常！ ClassCastException
-
存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();
不能被重写的 1. static方法，属于类，它不属于实例 2. final 常量 3.private方法
多态是方法的多态，属性没有多态性
public class A extends B{
public void run() {
System.out.println("run");
}
public void eat(){
System.out.println("rice");
}
}
public class B {
public void run(){
System.out.println("run");
}
}
public class Application {
public static void main(String[] args) {
A a = new A();
a.run();
B b = a;
((A)b).eat();
}
/*
父类引用指向子类对象
把子类指向父类，向上转型
把父类指向子类，向下转型 强制转换
方便方法的调用，减少重复代码！
*/
}
Static
public class StaticDome {
//2.赋初值
{
System.out.println("匿名代码块");
}
//1.只执行一次
static {
System.out.println("静态代码快");
}
//3.
public StaticDome(){
System.out.println("构造方法");
}
public static void main(String[] args) {
StaticDome s1 = new StaticDome();
System.out.println("=========================");
StaticDome s2 = new StaticDome();
}
}
abstract 抽象类 提高开发效率
// abstract抽象类 extends 单继承 （接口可以实现多继承）
public abstract class Action {
//约束
//抽象方法 只有方法名，没有方法实现
public abstract void doSomething();
//不能new出来 只能靠子类来实现它：约束！
//抽象类中 可以写普通方法
//抽象方法必须在抽象类中
}
//抽象类所有的方法，继承了他的子类，都必须实现到它的方法 除非抽象
public abstract class B extends Action{
public void run(){
System.out.println("run");
}
}
接口 ： 只有规范！自己无法写方法专业的约束！约束和实现分离：面向接口编程
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守
声明类的关键字是Class，声明接口的关键字是interface
//interface 关键字 接口都是需要实现类
public interface UseService {
//常量 public static final
int AGE = 66;
//接口中定义的方法其实都是抽象的 public abstract
void add();
void delete();
void update();
}
//类可以实现接口 implements接口
//实现了接口的类，就需要重写接口中的方法
//可以利用接口实现多继承
public class UseServiceImpl implements UseService{
@Override
public void add() {
}
@Override
public void delete() {
}
@Override
public void update() {
}
}
内部类：在一个类里面再写一个类，就叫内部类
public class Outer {
private int id = 10;
public void out(){
class out{//局部内部类
}
System.out.println("这是外部类");
}
public class Inner{//成员内部类
public void in(){
System.out.println("这是内部类");
}
//内部类可以直接调用外部类的私有属性
public void getId(){
System.out.println(id);
}
}
}
//一个文件里面可以有多个class 但只能有一个public class
class a{//静态内部类
public void eat(){
System.out.println("1");
}
}
interface UserService{
void holle();
}
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.getId();
new a().eat();//没有名字的始化类，不用将实例保存到变量中
// 匿名内部类
new UserService(){
@Override
public void holle() {
}
};
}
316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
