面向对象
什么是面向对象
-
面向对象编程(Object-Oriented Programming, 00P)
-
面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。“
-
抽象.
-
三大特性:
- 封装
- 继承
- 多态
-
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类,是抽象的，是对对象的抽象
-
从代码运行角度考虑是先有类后有对象。类是对象的模板。
方法的定义
-
修饰符 返回类型
/* 修饰符返回值类型方法名 (...){ //方法体 return返回值; } */ public String sayHe11o(){ return "he1lo , world"; } pub1ic int max (int a,int b){ return a>b ? a : b; //三元运算符! }2.break 和return的区别：
break跳出循环，return结束当前方
3.方法名 参数列表
方法的调用
静态方法
1、可以通过类直接调用，在类加载时加载，不能调用非静态方法
public class Demo01Static {
public static void main(String[] args) {
Student.say();
}
}
public class Student {
public static void say(){
System.out.println("学生说话了");
}
}
非静态方法
通过实例化对象调用
public class Demo01Static {
public static void main(String[] args) {
Student student = new Student();
student.say();
}
}
public class Student {
public void say(){
System.out.println("学生说话了");
}
}
形参和实参
值传递和引用传递
引用传递
public class Demo02 {
//引用传递:对象，本质还是值传递
//对象，内存!|
public static void main(String[] args) {
Perosn perosn = new Perosn();
System.out.println(perosn.name); //nuLL
Demo02.change(perosn);
System.out.println(perosn.name); //秦疆
}
public static void change(Perosn perosn){
//perosn是一个对象:指向的---> Perosn perosn = new Perosn();
// 这是一个具体的人， 可以改变属性!
perosn.name = "秦疆";
}
}
//定义了- -个Perosn类，有一个属性: name
class Perosn{
String name; //null
}
值传递
public class Demo03 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);//a=1
a(a);
System.out.println(a);//a=1
}
public static void a(int a){
a=10;
}
}
类与对象的关系.
- 类是一种抽象的数据类型,它是对某一类事物整体描述定义,但是并不能代表某一个具体的事物.
动物、植物、手机、电… .
Person类、Pet类、 Car类等, 这些类都是用来描述/定义某-类具体的事物应该具备的特点和行为 - 对象是抽象概念的具体实例
- 张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
- 能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念
创建与初始化对象
- 使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
封装
-
该露的露，该藏的藏
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
-
封装(数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
-
记住这句话就够了：属性私有，get/set
-
//类中只有属性和方法 public class Student { //类 private: 私有 //属性私有 private String name; //名字 private int id; //学号 private char sex; //性别 private int age; //提供一些可以操作这个属性的方法! //提供——public的get. set方法 //get获得这个数据 public String getName(){ return this.name; } //set给这个数据设置值 public void setName(String name){ this.name = name; } //alt + insert public int getAge() { return age; } public void setAge(int age) { if(age <0 || age > 120){ this.age = 3; }else { this.age = age; } } public int getId() { return id; } public void setId(int id) { this.id = id; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } }- 好处
- 提高程序的安全性，保护数据.
- 隐藏代码的实现细节
- 统一接口
- 系统可维护增加了
继承
-
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
-
extands的意思是“扩展”。子类是父类的扩展。
-
JAVA中类只有单继承，没有多继承!
-
被final修饰的类不能被继承。
-
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
- 子类和父类之间,从意义上讲应该具有"is a"的关系.
-
object类
java中的所有类都直接或间接继承Object类
-
super
- super注意点:
- super调用 父类的构造方法，必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中!
- super和 this 不能同时调用构造方法!
- Vs this:
- 代表的对象不同:
this 本身调用者这个对象
super:代表父类对象的应用 - 前提
this:没有继承也可以使用
super:只能在继承条件才可以使用 - 构造方法
this() ; 本类的构造
super():父类的构造!
- 代表的对象不同:
- super注意点:
- 好处
// 子类维承了父类，就会拥有父类的全部方法!
public class Student extends Person{
public Student() {
//隐藏代码:调用了父类的无参构造
super(); // 调用父类的构造器，必领要在子类构造器的第一一行
System.out.println("Student无参执行了");
}
public Student(String name) {
this .name = name ;
}
private String name = "qinjiang" ;
public void print(){
System.out.println("Student");
}
public void test1(){
print();//Student
this.print();//Student
super.print();//Person
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Person {
//一个类即使什么都不写，它也会存在个方法
//显示的定义构造器
protected String name ="kuangshen";
int age;
//alt+ insert
//1.使inew关键字， 本质是在调用构造器
//2.用例初始化值
public Person(){
System.out.println("Person");
}
//有参构造:一旦定义 了有参构造。无参就必须显示定义
public Person(String name){
this.name = name ;
}
public void print(){
System.out.println("Person");
}
}
方法重写
父类静态方法
public class Demo04_A extends Demo04_B{
public static void test(){
System.out.println("A==>test()");
}
}
12345
//重写都是方法的重写，和属性无关
public class Demo04_B {
public static void test(){
System.out.println("B==>test()");
}
}
123456
public class Applications {
public static void main(String[] args) {
//Demo04
//方法的调用只和左边，定义的数据类型有关
Demo04_A a = new Demo04_A();
a.test();//A==>test()
//父类引用指向引用
Demo04_B b = new Demo04_A();
b.test();//B==>test()
}
}
1234567891011
父类非静态方法
public class Applications {
public static void main(String[] args) {
//Demo04
/*
静态方法和非静态方法区别很大
静态方法：方法的调用只和左边，定义的数据类型有关
非静态方法：重写，父类方法只能是public
*/
Demo04_A a = new Demo04_A();
a.test();//A==>test()
//父类引用指向引用
Demo04_B b = new Demo04_A();//子类重写了父类的方法
b.test();//A==>test()
}
}
123456789101112131415
//重写都是方法的重写，和属性无关
public class Demo04_B {
public void test(){
System.out.println("B==>test()");
}
}
123456
public class Demo04_A extends Demo04_B{
@Override
public void test() {
System.out.println("A==>test()");
}
}
- 重写:需要有继承关系，子类重写父类的方法!
- 方法名必须相同
- 参数列表列表必须相同
- 修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
- 抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)
- 重写，子类的方法和父类必要一 致;方法体不同!
- 为什么需要重写:
- 父类的功能，子类不一定需要， 或者不一定满足!
- Alt +Insert ;---->override;
2342
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
