目录
1 .类和对象
1.1概念
1.2类定义
1.3对象使用
2 .软件包
2.1思想封装
2.2隐私和this
3 .继承
3.1思想继承
3.2方法改写
3.3 Java继承注意事项：
4 .多态性
4.1多态性思想
4.2多态性上的变革
如何理解面向对象？
简而言之，就是把事物和操作事物的方法放在一起，形成相互依存的整体。
这里介绍了面向对象的基本知识
1 .类和对象1.1概念对象：客观存在的都是对象。 例如，猫、狗
班：说明事物，比如猫睡觉，猫抓老鼠
类配置：
属性：指事物的特征，如电脑(品牌、价格) )
行为(事物可以执行的操作，例如电脑的使用(看电影、玩游戏) )。
1.2类定义类定义步骤：
班级的定义
创建类的成员变量
创建类的成员方法
示例代码：
公共类电话{//成员变量String brand； int price； //成员方法public void call ((system.out.println ) )“打电话”； } public void sendMessage (() { System.out.println ) }发送邮件)； }} 1.3使用对象创建对象格式：
类名对象名=new类名(；
调用成员格式：
对象名称.成员变量
对象名称.成员方法(；
示例代码：
publicclassphonedemo { publicstaticvoidmain (字符串[ ] args )//要创建的Phone p=new Phone )； //成员变量p.brand='小米'； p.price
= 2999; System.out.println(p.brand); System.out.println(p.price); //使用成员方法 p.call(); p.sendMessage(); }} 2. 封装 2.1 封装思想概述：封装是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
原则：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法
好处：通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性
使用封装前，需要先了解一些修饰符
2.2 private 和 thisprivate，意思为私有的，它是用来修饰成员变量和成员方法的
this，修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
从单词意思上就知道被private修饰的成员，只能在本类进行访问
那么针对private修饰的成员变量，如果需要被其他类使用，则提供相应的操作：
1）提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
2）提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
示例代码：
public class Animal { private String name; private int age; 提供get/set方法 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; } //成员方法 public void show() { System.out.println(name+","+age); } public class Test { public static void main(String[] args) { //创建对象 Animal a = new Animal(); //给成员变量赋值 a.setName("喵喵"); a.setAge(20); //调用show方法 a.show(); }}运行结果：
3. 继承 3.1 继承思想继承是什么？
一个类（子类）拥有另一个类（父类）的所有功能，不需要编写原来的类，还可以对功能拓展
继承的利与弊：
好处：提高了代码的复用性，提高了代码的维护性
弊端：削弱了子类的独立性，父类变化子类也跟着变化
子类默认访问父类的无参构造方法，但也可以通过super关键字调用有参的构造方法
下面我们通过代码了解子类继承的构造方法：
1.创建一个Animal类，有属性name和age，提供有参和无参的构造方法
public class Animal { String name; int age; public Animal() { } public Animal(String name, int age) { this.name = name; this.age = age; } 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; }}2.创建一个Cat类，并继承Animal类，声明方法catMouse
public class Cat extends Animal{ public Cat(){ } public Cat(String name, int age) { super(name, age); } public void catMouse(){ System.out.println("猫抓老鼠"); }}3.创建一个测试类Test
public class Test { public static void main(String[] args) { Cat c1 = new Cat(); //创建对象c1，使用无参构造方法 c1.setName("喵喵"); c1.setAge(20); System.out.println(c1.getName()+" "+c1.getAge()); Cat c2 = new Cat("咪咪",15); //创建新的对象c2,使用有参构造方法 System.out.println(c2.getName()+" "+c2.getAge()); c1.catMouse(); //调用方法 }}4.运行结果
3.2 方法重写继承还有一个重要内容，就是方法重写
方法重写就是子类和父类的方法名一样，参数列表也一样
为什么要进行方法重写：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
Override注解：
用来检测当前的方法，是否是重写的方法，起到【校验】的作用
方法重写注意事项
1. 私有方法不能被重写(父类私有成员子类是不能继承的)
2. 子类方法访问权限不能更低(public > 默认 > 私有)
代码举例：
public class Fu { private void show() { System.out.println("Fu中show()方法被调用"); } void method() { System.out.println("Fu中method()方法被调用"); }} public class jqdhy extends Fu { /* 编译【出错】，子类不能重写父类私有的方法*/// @Override// private void show() {// System.out.println("jqdhy中show()方法被调用");// } /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */// @Override// private void method() {// System.out.println("jqdhy中method()方法被调用");// } /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */ @Override public void method() { System.out.println("jqdhy中method()方法被调用"); }} public class Test { public static void main(String[] args) { jqdhy z = new jqdhy(); z.method(); }}运行结果：
3.3 Java继承的注意事项：1） Java中类只支持单继承，不支持多继承
错误范例：class A extends B, C { }
2）Java中类支持多层继承
多态就是同一个对象，在不同时刻表现出来的不同形态
多态的前提：
1.要有继承或实现关系
2.要有方法的重写
3.要有父类引用指向子类对象
多态的利弊：
好处：提高了程序的扩展性
弊端：不能使用子类的特有成员
4.2 多态中的转型向上转型：父类 对象名 = new 子类
向下转型：子类型 对象名 = (子类型)父类引用
举例说明：
public class Animal { public void eat() { System.out.println("动物吃东西"); }} public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } public void playGame() { System.out.println("猫捉迷藏"); }} public class Test { public static void main(String[] args) { //多态 //向上转型 Animal a = new Cat(); a.eat(); //向下转型 Cat c = (Cat)a; c.eat(); c.playGame(); }}运行结果：
总结：面向对象的三大基本特征介绍就完毕了，但面向对象不止这些特征。后续我会发布新的内容，请持续关注！！！