面向对象
面向过程:更注重操作的步骤 (微观)
面向对象:更注重的参与者(宏观)
类和对象的关系:
类是抽象的,对象是具体的
类是对象类型,对象是类的实例
编写类:类名,属性,方法
使用类:创建对象,给属性赋值,调用方法
成员变量与局部变量的区别
区别 | 成员变量 | 局部变量 |
---|---|---|
位置不同 | 类中,方法外 | 方法里,方法的形参,代码块里 |
作用范围不同 | 整个类,整个类中的所有方法均可以使用 | 只限于当前方法,或者当前语句块 |
内存的存放位置不同 | 存储在堆内存 | 存储在栈内存 |
有无默认值 | 有默认值 | 没有默认值 |
构造方法(构造器)
1.方法名必须与类名相同
2.不能写返回值,也比能写void,更不能使用return
3. 构造方法可以重载
构造方法与成员方法的区别
区别 | 构造方法 | 成员方法 |
---|---|---|
作用不同 | 用于创建对象,并给属性初始化 | 描述对象所具有的行为 |
调用/使用方式不同 | 使用new关键字调用 | 使用对象名调用 |
执行顺序不同 | 先执行构造方法创建对象 | 然后使用对象名去调用成员方法 |
是否开空间 | 每执行一次都将在堆中开一个空间 | 可以被同一个对象调用N多次,调用一次加载到栈内存一次,执行完出栈 |
this关键字
this代表的是当前对象的引用(地址)
作用:
(1)使用本类的属性 this.属性,, this可以省略不写
(2)使用本类的中方法 this.方法(),this可以省略不写
(3)调用本类的其它构造方法 this() ,this(…) ,要求必须是构造方法中第一句代码
(4)用于区分成员变量和局部变量this…代表成员变量
static关键字
(1) static可以修饰成员变量 ,称为静态变量 ,在方法区
标准 使用方式: 类名.静态变量名
(2)static可以修饰成员方法,称为静态方法
标准使用方式: 类名.方法名();
(3)static 修饰代码块:称为静态代码块, 为类的静态变量进行赋初始值
构造方法,构造代码块,静态代码块执行顺序:
静态代码块>构造代码块>构造方法
(4)修饰内部类 称为静态内部类
注意事项:
static方法不允许使用成员变量
final关键字
(1) final修饰的变量称为常量
final修饰成员变量,通常与static一起使用,称为静态常量
final修饰的局部变量称为常量
final修饰的基本数据类型,其值不允许更改
final修饰的引用数据类型, 其地址不允许更改
(2)修饰方法 :不允许子类重写,但是可以被子类调用
(3)修饰类:不允许有子类的,所以称为太监类
abstract关键字
(1)修饰类称为抽象类(特征:就是不能创建对象)
(2)修饰方法 :使用abstract修饰的方法称为抽象方法
抽象方法的特点:
1没有方法体,只能以分号结尾
2.必须定义在抽象类里
3.必须被子类实现,如果子类不实现,那么子类也得是抽象类
注:抽象类里可以包含0个或多个抽象方法,抽象方法必须定义在抽象类中
interface关键字
类与接口的关系 implements(实现)
一个类即存在继承关系又存在实现关系,继承在前(extends),实现在后 (implements)
接口中的变量均为公共的静态常量
java中的类是单继承的,java中的接口是多继承的
super关键字
(1)调用父类的非私有属性
(2)调用父类的构造方法,要求必须是构造方法中第一句代码
(3)调用父类的非私有成员方法
(4)用于父类与子类的同名属性的区分,super指代的是父类,this指代的是子类
面向对象的三大特征
(1)封装:提高程序的安全性
(2)继承:提高代码的复(重复使)用性
(3)多态:提高程序的扩展性
封装:访问权限
public :最大的访问权限
protected :子类方访问权限
package :包内访问权限
private :本类访问权限
方法重载
(1)在一个类里面为一种行为提供多种实现方式并提高可读性
(2)方法名相同,参数不同(类型不同,个数不同,顺序不同)
方法重写
(1)父类方法无法满足子类的要求,子类通过方法重写满足要求
(2)发生在子类
(3)方法名,参数类型,个数,顺序必须与父类完全相同
(4)子类返回值小于等于父类的返回值
(5)子类访问权限大于等于父类的访问权限
多态的前提
(1)继承是多态的前提
(2)子类重写父类的方法
(3)父类引用 new子类对象
如何使用封装去保证属性的安全性
(1)属性私有化 private
(2)提供公有的取值,赋值方法
(3)在赋值的方法中进行值的合理性验证
封装代码:
/**
* @author lh
* @since JDK 1.8
* ClassName: Person
* date: 2019/8/17 16:37
* Description:
* 定义Person类
* 属性私有化
* 提供共有的取值赋值方法
* 在赋值的方法内进行合理性验证
*/
public class Person {
//属性私有化
private String name;
private int age;
private String gender;
//提供共有的取值赋值方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
//在赋值的方法中对值进行合理性验证
if(age<=18||age>=25){
System.out.println("对不起,年龄要在18到25之间");
this.age=18;//给属性设置默认值
}else{
this.age=age;//将局部变量的值赋给成员变量
}
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
//在赋值的方法中对值进行合理性验证
if(!"男".equals(gender)&&!"女".equals(gender)){
System.out.println("对不起,性别有误");
this.gender="男";//给属性设置默认值
}else{
this.gender=gender;
}
}
//无参构造
public Person() {
}
//带参构造
public Person(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//成员方法
public void show(){
System.out.println(name+"\t"+age+"\t"+gender);
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: TestPerson
* date: 2019/8/17 16:57
* Description:
* 定义测试类
*/
public class TestPerson {
public static void main(String[] args) {
Person p=new Person();//创建对象(无参)
p.setAge(5);
System.out.println(p.getAge());//对不起,年龄要在18到25之间 设置为18
Person pp=new Person("王小五",22,"人妖");//创建带参构造
pp.show();//提示错误信息 :对不起,性别有误 王小五 22 男(改为默认值)
}
}
继承代码(一父二字一测试)
/**
* @author lh
* @since JDK 1.8
* ClassName: Animal
* date: 2019/8/17 19:05
* Description:
* 定义一个Animal类
* 定义两个私有属性 color age
* 三个方法 eat sleep introduce
*/
public class Animal {
private String color;
private int age;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println("我饿了,我想吃东西!!!");
}
public void sleep(){
System.out.println("我困了,我想睡觉!!!!");
}
public void introduce(){
System.out.println("Animal:"+color+" "+age);
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: Dog
* date: 2019/8/17 19:09
* Description:
* 定义一个dog类
* dog直接继承animal类 ,间接继承object类
* 一个私有属性 name
* 定义一个自己方法
* 覆盖父类的方法
* 重写父类的introduce方法
*/
public class Dog extends Animal {//extend继承 dog类继承animal类
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("小狗汪汪汪!!!");
}
@Override
public void introduce() {//重写父类的introduce
System.out.println("我是二哈,我会拆家!!!");
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: Cat
* date: 2019/8/17 19:14
* Description:
* 定义cat类
* 一个私有属性 name
* 一个方法 show
*/
public class Cat extends Animal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("我会捉老鼠!!!");
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: Test
* date: 2019/8/17 19:17
* Description:
* 编写测试类
* 创建两个对象 dog和cat
*/
public class Test {
public static void main(String[] args) {
//dog
Dog dog=new Dog();//创建对象
dog.setName("二哈");
dog.setAge(2);
dog.setColor("黑白相间");
dog.eat();//从父类继承
dog.introduce();//方法重写调用自己的
dog.sleep();//从父类继承
dog.show();//子类自己的
//cat
Cat cat=new Cat();
cat.setColor("橘色");
cat.setAge(3);
cat.eat();
cat.introduce();
cat.sleep();
cat.show();
}
}
多态代码(一父二字一测试)
/**
* @author lh
* @since JDK 1.8
* ClassName: Car
* date: 2019/8/17 20:20
* Description:
* 定义汽车类
* 定义两个方法 run show
* run子类继承
* show子类重写
*/
public class Car {
//子类继承
public void run(){
System.out.println("我在公路上驰骋,不允许飙车!!!");
}
//子类重写
public void show(){
System.out.println("我是辆好车!!!");
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: Bwm
* date: 2019/8/17 20:25
* Description:
* 定义bwm类
* 重写父类手方法
* 自己定义speed方法(独有)
*/
public class Bwm extends Car {
//重写父类方法
@Override
public void show() {
System.out.println("我是宝马!!!");
}
//子类特有
public void speed(){
System.out.println("我可以达到200迈");
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: Fll
* date: 2019/8/17 20:31
* Description:
* 定义Fll类
* 重写父类show方法
* 自己定义login方法
*/
public class Fll extends Car {
@Override
public void show() {
System.out.println("我是法拉利!!!");
}
public void login(){
System.out.println("我的车标是一匹奔腾的马!!!");
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: TestCar
* date: 2019/8/17 20:35
* Description:
* 定义测试类TestCar
* 1.没有使用多态 只能调用父类的方法
* 2.使用多态 父类引用 new子类对象
* 向上类型转换(自动类型转换)
* 只能调用父类中存在的方法,或者是重写的方法
* 在子类中定义的方法将不能使用
* 向下类型转换(强制类型转换) 可以调用子类独有的方法
*/
public class TestCar {
public static void main(String[] args) {
//没有使用多态 只能调用父类的方法
Car c=new Car();
c.run();
c.show();
//使用多态 父类引用 new子类对象
//向上类型转换(自动类型转换)
//只能调用父类中存在的方法,或者是重写的方法
//在子类中定义的方法将不能使用
Car car=new Bwm();
car.show();
//向下类型转换(强制类型转换)
Bwm b=(Bwm)car;
b.speed();//调用子类独有的方法
Car car1=new Fll();//使用多态
car1.show();
Fll f=(Fll) car1;
f.login();//调用子类独有的方法
}
}
接口的使用
/**
* @author lh
* @since JDK 1.8
* ClassName: Human
* date: 2019/8/17 14:14
* Description:
* 定义一个人类的统称
* 定义接口
* 定义三个方法 laugh cry talk
*/
public interface Human {//首先定义什么是人类
//人是快乐的,会笑
public void laugh();
//人类还会哭。代表痛苦
public void cry();
//人类还会说话
public void talk();
}
/**
* @author lh
* @since JDK 1.8
* ClassName: YellowHuman
* date: 2019/8/17 14:32
* Description:
* 定义具体的人类
* 黄种人
* 重写human接口的三个方法
*/
public class YellowHuman implements Human {
@Override
public void laugh() {
System.out.println("黄种人会笑,开心呀!幸福呀!");
}
@Override
public void cry() {
System.out.println("黄种人会哭,有心事!");
}
@Override
public void talk() {
System.out.println("黄种人会说话,一般都是双字节!");
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: WhiteHuman
* date: 2019/8/17 14:37
* Description:
* 定义白种人
* 重写human接口的三个方法
*/
public class WhiteHuman implements Human {
@Override
public void laugh() {
System.out.println("白种人会大笑,侵略的笑声!");
}
@Override
public void cry() {
System.out.println("白种人也会哭!");
}
@Override
public void talk() {
System.out.println("白种人会说话,一般都是单字节!");
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: BlockHuman
* date: 2019/8/17 14:42
* Description:
* 定义黑人 类
* 重写human接口的三个方法
*/
public class BlockHuman implements Human{
@Override
public void laugh() {
System.out.println("黑人会笑。");
}
@Override
public void cry() {
System.out.println("黑人也会哭!");
}
@Override
public void talk() {
System.out.println("黑人会说话,一般人听不懂!");
}
}
/**
* @author lh
* @since JDK 1.8
* ClassName: Test
* date: 2019/8/17 21:06
* Description:
* 定义测试类
* 创建三个实例
* 分别调用自己的方法
*/
public class Test {
public static void main(String[] args) {
Human h=new BlockHuman();
h.cry();
h.laugh();
h.talk();
Human h1=new YellowHuman();
h1.cry();
h1.laugh();
h1.talk();
Human h2=new WhiteHuman();
h2.cry();
h2.laugh();
h2.talk();
}
}
注:一定要理解,理解,理解,多做练习!!!