一 面向对象思想
面向对象是基于面向过程的编程思想。
面向对象思想特点:
是一种更符合我们思想习惯的思想;
可以将复杂的事情简单化;
将我们从执行者变成了指挥者。
面向对象开发:就是不断的创建对象,使用对象,指挥对象做事情。
面向对象设计:其实就是在管理和维护对象之间的关系。
面向对象特征:封装、继承、多态。
二 对象与类的关系
类:可以理解为构造对象的一个蓝图或者模版,是抽象的概念
对象:是以类为模型创建的具体实例,是对类的一种具体化。
三 定义类
定义类其实就是定义类的成员(成员变量和成员方法)。
成员变量和局部变量的区别:
在类中的位置不同:
成员变量 类中方法外;
局部变量 方法内或者方法声明上。
在内存中的位置不同:
成员变量 堆内存;
局部变量 栈内存。
生命周期不同:
成员变量 随着对象的存在而存在,随着对象的消失而消失;
局部变量 随着方法的调用而存在,随着方法的调用完毕而消失。
初始化值不同:
成员变量 有默认的初始化值;
局部变量 没有默认的初始化值,必须先定义,赋值,才能使用。
四 封装
封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
封装的好处:
隐藏实现细节,提供公共的访问方式;
提高了代码的复用性;
提高安全性。
封装原则:
将不需要对外提供的内容都隐藏起来;
把属性隐藏,提供公共方法对其访问。
public class PersonTest {
public static void main(String[] args){
//创建人对象
Person p = new Person();
p.setName("小明");
p.setAge(25);
p.setWeight(99.9);
System.out.println("姓名"+
p.getName() + "年龄是:"+ p.getAge()
+ "体重是:"+ p.getWeight());
p.say("好好学习,天天向上");
}
}
class Person{
//成员变量
private String name; //姓名
private int age; // 年龄
private double weight; //体重
//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 double getWeight(){
return weight;
}
public void setWeight(double weight){
this.weight = weight;
}
//成员方法
public void say(String words){
System.out.println( name +"说:" + words );
}
}
五 关键字private、this、static
private关键字:
是一个权限修饰符;
可以修饰成员(成员变量和成员方法);
被private修饰的成员只在本类中才能访问。
this关键字:
代表所在类的对象引用。
static关键字:
可以修饰成员变量和成员方法;
static关键字特点;
随着类的加载而加载;
优先于对象存在;
被类的所有对象共享(这也是我们判断是否使用静态关键字的条件);
可以通过类名调用;
static关键字注意事项:
在静态方法中是没有this关键字的;
静态方法只能访问静态的成员变量和静态的成员方法。
六 继承
继承概述:
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。
通过extends关键字可以实现类与类的继承。
格式:ss 子类名 extends 父类名{}
在Java中只支持单继承,不支持多继承,但是支持多层继承。
注意事项:
子类只能继承父类所有非私有的成员(成员方法和成员变量)。其实这也体现了继承的另一个弊端:打破了封装性。
子类不能继承父类的构造方法,但是可以通过super关键字去访问父类构造方法。关键字super代表父类存储空间的标识(可以理解为父类引用)。
七 方法的重写
方法重写概述:子类中出现了和父类中一模一样的方法声明,也被称为方法覆盖,方法复写。
使用特点:
如果方法名不同,就调用对应的方法;
如果方法名相同,最终使用的是子类自己的。
方法重写的应用:
当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。
注意事项:
父类中私有方法不能被重写;
子类重写父类方法时,访问权限不能低于父类的;
父类静态方法,子类也必须通过静态方法进行重写。
public class Demo1 {
public static void main(String[] args) {
// 创建学生对象
Student s = new Student("小明", 19);
s.study("java");
s.eat("果子");
s.sleep();
// 创建老师对象
Teacher t=new Teacher("李老师",30);
t.teach("安卓");
t.eat("苹果");
t.sleep();
}
}
// 定义Person类
class Person {
// 成员变量
private String name;
private int age;
// 构造方法
Person() {}
Person(String name, int age) {
this.name = name;
this.age = 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 eat(String food) {
System.out.println("吃" + food);
}
// 睡觉
public void sleep() {
System.out.println("睡觉了!");
}
}
// 定义学生类
class Student extends Person {
Student() {}
Student(String name, int age) {
super(name,age);
}
// 学生的学习方法
public void study(String course) {
System.out.println(" study_ " + course);
}
}
//定义教师类
class Teacher extends Person {
Teacher() {}
Teacher(String name, int age) {
super(name,age);
}
// 教师的方法讲课
public void teach(String course) {
System.out.println("讲 ... " + course);
}
}
八 关键字final
final关键字是最终的意思,其特点是:
1:这个关键字是一个修饰符,可以修饰类,方法,变量。
2:被final修饰的类是一个最终类,不可以被继承。
3:被final修饰的方法是一个最终方法,不可以被覆盖。
4:被final修饰的变量是一个常量,只能赋值一次。
public class Demo6 {
public static void main(String[] args){
Zi z = new Zi();
z.show();
System.out.println();
final int x = 10;
//x =20; // 值不能改变
final int[] arr = {123,4455};
//arr = new int[3]; //地址值不能改变
}
}
//final class Fu{ } // 错误: 无法从最终Fu进行继承
class Fu{
//final int num =10;
//final int num;
final String s = "192.168.36.72";
public final void eat(){
System.out.println("吃饭");
}
}
class Zi extends Fu{
public void show(){
//super.num = 20; //错误: 无法为最终变量num分配值
//super.num = 20;
//super.s = "ffff";
//System.out.println( "num :" + super.num);
}
/*public final void eat(){
System.out.println("不吃了");
}*/// Zi中的eat()无法覆盖Fu中的eat()
}