面向对象语言的三大特征：
封装、继承、多态
1. 面向对象的特征——封装定义：将类的某些信息隐藏起来（访问权限修饰符），不让在外部直接对其访问，可以通过一个特定的方法，来对隐藏的信息进行访问，便于访问。
例1：
public class Student {
private String name;//隐藏类的属性
private int age;
public Student(){
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public static void main(String[] args) {
Student stu = new Student();
stu.setName("张三");
System.out.println(stu.getName());
stu.setAge(16);
System.out.println(stu.getAge());
}
}
例2：
设计模式：解决某一类问题的解决方案（模式）
单例模式 ---> 让一个类在一个程序，只能创建一个对象。
public class studentDao {
private static studentDao stu = null;
private studentDao(){
}
//将构造方法私有化，在其他类中不能随便使用
public static studentDao getStu(){
if(stu == null){
stu = new studentDao();
return stu;
}
return stu;
}
public static void main(String[] args) {
System.out.println(studentDao.getStu());
System.out.println(studentDao.getStu());
}
}
2. 面向对象的特征——继承
2.1 继承
定义：子继承父，实现代码的重用，提高代码的可扩展性。
什么清空下使用继承？
是用一类，什么是什么，is-a关系
将子类的共有的属性和方法
语法：[ 访问权限修饰符][修饰符] 子类名 extends 父类名{ }
名词：父类（基类） 子类（派生类）
继承的传递性：
C类继承B类，B类继承A类，C类继承B、C类中非私有的属性和方法。
使用extends 关键字
一个类只能直接继承一个父类，继承后子类就可以使用父类中非私有的成员方法和属性，
在子类中可以扩展子类特有的属性和方法。
//当一个类中没有显示的继承某个类，那么这个类默认继承object类，object这个类是所有类的基类
//public class Animal extends Object{}
public class Animal{
//成员变量
private String name;
private int age;
//构造方法
public Animal(){
}
//访问私有成员属性的入口
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 eat(){
System.out.println(name + "吃东西");
}
}
public class Panda extends Animal{
public Panda(){
}
public void eat(){
System.out.println("构造方法");
super.eat();
}
public void play(){
System.out.println("功夫熊猫");
}
}
public class Yu extends Panda{
public Yu(){
}
public void KongFu(){
System.out.println("鱼鱼是只会耍双节棍的熊猫");
}
}
public class Test {
public static void main(String[] args) {
//调用父类的非私有方法
Dog dog = new Dog();
dog.setName("小段");
dog.setAge(5);
dog.eat();
System.out.println(dog.getName());
System.out.println(dog.getAge());
//调用父类的非私有方法
Panda panda = new Panda();
panda.setName("食铁兽");
panda.setAge(7);
panda.eat();
//子类特有的方法
panda.play();
//继承具有传递性 C继承B，B继承A C类具有B、A类中的非私有的属性和方法。
Yu yu = new Yu();
yu.setAge(5);
yu.setName("鱼鱼");
System.out.println(yu.getName());
System.out.println(yu.getAge());
yu.eat();
//调用父类
yu.play();
//调用父类的父类
yu.KongFu();
}
}
2.2 继承的构造方法
在创建一个子类对象后，调用构造方法时，从上向下调用，先初始化父类信息
使用super() 在子类构造方法的第一行默认执行，调用父类无参的构造方法。
super() 表示调用父类中无参构造，默认存在的，必须放在第一行。
public class Animal extends Object{
private String name;
private int age;
public Animal(){
super();
System.out.println("animal类的无参构造方法");
}
public Animal(int age){
this.age = age;
System.out.println("Animal类的有参构造方法");
}
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 eat(){
System.out.println(name + "吃东西");
}
}
public class Panda extends Animal{
public Panda(){
super();
System.out.println("Panda类的无参构造方法");
}
public Panda(int age){
super(age);
System.out.println("Panda类的有参构造方法");
}
@Override
public void eat(){
System.out.println("熊猫抱着竹子吃");
}
public void play(){
System.out.println("功夫熊猫 : 呼呼哈嘿");
super.eat();
}
}
public class Yu extends Panda{
public Yu(){
super();
System.out.println("Yu的无参构造方法");
}
public Yu(int age){
super(age);
System.out.println("Yu的有参构造方法");
}
public void KongFu(){
System.out.println("鱼鱼是只会耍双节棍的熊猫");
}
}
public class Test1 {
public static void main(String[] args) {
Yu yu1= new Yu(5);
//继承具有传递性 C继承B，B继承A C类具有B、A类中的非私有的属性和方法。
Yu yu = new Yu();
yu.setAge(5);
yu.setName("小鱼儿");
System.out.println(yu.getName());
System.out.println(yu.getAge());
yu.eat();
//调用父类
yu.play();
//调用父类的父类
yu.KongFu();
}
}
2.3 方法的重写
原因：当父类的方法实现不能满足子类需求时，需要进行重写
方式：在子类中对父类中的方法进行重写
规则：
- 方法名相同
- 参数列表相同
- 返回值类型相同
- 访问权限修饰符不能等于或者大于父类的权限
@override Java中提供的一个注解标签（一种标记）
添加此注解的标签表示此方法是从父类重写过来的，就会对其进行语法验证。
注：@overload(重载）
public class Animal extends Object{
private String name;
private int age;
public Animal(){
}
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 eat(){
System.out.println(name + "吃东西");
}
}
public class Panda extends Animal{
public Panda(){
}
@Override //Java中提供的一个注解标签（一种标记）
public void eat(){
System.out.println("熊猫抱着竹子吃");
}
public void play(){
System.out.println("功夫熊猫 : 呼呼哈嘿");
super.eat();
}
}
public class Yu extends Panda{
public Yu(){
}
public void KongFu(){
System.out.println("鱼鱼是只会耍双节棍的熊猫");
}
}
public class Test2 {
public static void main(String[] args) {
Yu yu = new Yu();
yu.setName("小鱼儿");
yu.setAge(1);
yu.eat();
yu.play();
}
}
3. 抽象类 4. 面向对象的特征——多态 5. final关键字 6. 接口
