简单类举例
package com.itcast.demo;
public class Phone {
String model;
String brand;
String name;
public void call(String name) {
System.out.println("给" + name + "打电话");
}
public void send(String name) {
System.out.println("给" + name + "发信息");
}
public void play() {
System.out.println("玩游戏");
}
}
package com.itcast.demo;
public class PhoneTest {
public static void main(String[] args) {
Phone phone = new Phone();
phone.name = "asd";
phone.brand = "小米";
phone.model = "12";
phone.call("小安");
phone.send("小黑");
phone.play();
}
}
封装
封装的好处
- 提高安全性
- 提高复用性
- 将复杂的事情简单化
private的基本概念
私有的,一种访问权限修饰符,用来修饰类的成员
特点
被修饰的成员只能在本类中访问
用法
private 数据类型 变量名;
private 返回值类型 方法名(参数列表) { }
this关键字
this的基本概念
这,这个,表示本类对象的引用,本质是一个对象
特点
每一个普通方法都有一个this,谁调用该方法,this就指向谁
用法
this.属性名; this.方法名(参数);
package com.itcast.demo;
public class StudentTest {
public static void main(String[] args) {
Student stu = new Student();
Student stu1 = new Student("张三", 19);
System.out.println(stu1.getName());
System.out.println(stu1.getAge());
}
}
package com.itcast.demo;
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
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;
}
}
继承
通过扩展一个类来建立另外一个类的过程,叫做继承(inheritance) 通俗地说,所谓继承,就是让类与类之间产生父子关系。 所有的类都直接或间接的继承自: java.lang.Object 被继承的类叫做父类(基类、超类) 继承的类叫做子类(派 生类)
格式(extends)
子类继承父类之后有什么效果?
子类拥有了父类的非私有成员(成员变量、成员方法)
父类Animal:
package com.itcast.demo2;
public class Animal {
private String name;
private int age;
private String sex;
public Animal() {
}
public Animal(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
子类Dog:
package com.itcast.demo2;
public class Dog extends Animal {
public void eat() {
System.out.println("小狗" + getName() + "爱吃骨头");
}
public void speak() {
System.out.println("小狗" + getName() + "汪汪叫");
}
}
子类Pig:
package com.itcast.demo2;
public class Pig extends Animal {
public void sleep() {
System.out.println("小猪" + getName() + "爱睡觉");
}
}
测试类:
package com.itcast.demo2;
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
Dog dog1 = new Dog();
Pig pig = new Pig();
dog.setName("望望");
dog1.setName("猜猜");
pig.setName("珠珠");
dog.eat();
dog1.speak();
pig.sleep();
}
}
方法重写(Override)
定义:
子类中出现和父类方法定义相同的方法的现象
解释:
- 方法重写也叫方法的复写、覆盖
- 方法名、参数列表、返回值类型都相同
注意事项:
- 父类私有方法无法重写
- 子类方法访问权限不能小于父类方法
- 子类不能比父类方法抛出更大的异常(了解)
使用场景:
扩展父类功能 父类功能过时,重新实现父类功能
访问权限修饰符
private:强调给自己使用
默认:强调给同包下的类来使用
protected:强调给子类使用
public:强调给大家使用
方法重写和方法重载的区别:
方法重载:同一个类中,出现两个或两个以上同名方法时,其参数列表不同,称为方法重载,与返回值类型和修饰符无关。
方法重写:子类出现和父类相同的方法时称为方法重写,要求参数列表和返回值相同。
继承的特点
多态
什么是多态?
多种状态,同一对象在不同情况下表现出不同的状态或行为
Java中实现多态的步骤
- 要有继承(或实现)关系
- 要有方法重写
- 父类引用指向子类对象(is a关系)
package com.itcast.demo3;
public class Animal {
private String name;
public Animal() {
}
public Animal(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void eat() {
System.out.println("恰饭");
}
}
package com.itcast.demo3;
public class Dog extends Animal{
@Override
public void eat(){
System.out.println(getName()+"吃骨头");
}
}
package com.itcast.demo3;
public class Test {
public static void main(String[] args) {
Animal a = new Dog();
a.setName("小黑");
a.eat();
}
}
多态的好处和弊端
多态的好处
可维护性:
基于继承关系,只需要维护父类代码,提高了代码的复用性,大大降低了维护程序的工作量
为什么要学习多态:
从程序的模块化和复用性来解释
封装:隐藏数据的实现细节,让数据的操作模块化,提高代码复用性
继承:复用方法,从对象的行为这个层面,提高代码的复用性
多态:复用对象,程序运行时同一个对象表现出不同的行为
可扩展性:
把不同的子类对象都当作父类看待,屏蔽了不同子类对象间的差异,做出通用的代码,以适应不同的需求,实现了向后兼容
多态的弊端
不能使用子类特有成员
解决办法:
向下转型(前提:必须准确知道该父类引用指向的子类类型)
类型转换
当需要使用子类特有功能时,需要进行类型转换
向上转型(自动类型转换)
// 子类型转换成父类型
Animal animal = new Dog();
向下转型(强制类型转换)
// 父类型转换成子类型
Dog dog = (Dog)animal;
注意事项
只能在继承层次内进行转换,否则可能造成异常( ClassCastException ) 将父类对象转换成子类之前,使用 instanceof 进行检查
package com.itcast.demo4;
public class Animal {
public void eat() {
System.out.println("吃饭");
}
}
package com.itcast.demo4;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void watch() {
System.out.println("狗会看家");
}
}
package com.itcast.demo4;
public class Test {
public static void main(String[] args) {
Animal an = new Dog();
an.eat();
//向下转型 instanceof判断类型是否可以转换
if (an instanceof Dog) {
Dog dog = (Dog) an;
dog.watch();
}
}
}
抽象类
抽象类的概念
包含抽象方法的类。用abstract修饰
抽象方法的概念
只有方法声明,没有方法体的方法。用abstract修饰
抽象方法的由来
当需要定义一个方法,却不明确方法的具体实现时,可以将方法定义为abstract,具体实现延迟到子类
package com.itcast.demo5;
//抽象类
public abstract class Animal {
//抽象方法(要求子类必须重写)
public abstract void eat();
}
package com.itcast.demo5;
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
package com.itcast.demo5;
public class Mouse extends Animal {
@Override
public void eat() {
System.out.println("老鼠吃奶酪");
}
}
package com.itcast.demo5;
public class Test {
public static void main(String[] args) {
//老鼠类
Animal m = new Mouse();
m.eat();
//狗类
Animal d = new Dog();
d.eat();
}
}
抽象类的特点
抽象类成员的特点
成员变量: 可以有普通的成员变量,也可以有成员常量(final)
成员方法: 可以有普通方法,也可以有抽象方法 抽象类不一定有抽象方法,有抽象方法的类一定是抽象类(或接口)
构造方法: 像普通类一样有构造方法,且可以重载。
final关键字
final的作用
用于修饰类、方法和变量
修饰类: 该类不能被继承(可以继承别人)
String, System
修饰方法: 该方法不能被重写 不能与abstract共存
修饰变量: 最终变量,即常量,只能赋值一次 不建议修饰引用类型数据,因为仍然可以通过引用修改对象的内部数据,意义不大。
static关键字
static的作用
用于修饰类的成员 : 成员变量:类变量 成员方法:类方法
调用方式 类名. 成员变量名; 类名. 成员方法名(参数);
static修饰成员变量
特点: 被本类所有对象共享
接口
package com.itcast.demo7;
public interface Smoking {
public abstract void smoke();
}
public class People implements Smoking {
@Override
public void smoke() {
System.out.println("吸烟有害健康");
}
}
public class Test {
public static void main(String[] args) {
Smoking s = new People();
s.smoke();
}
}