2.面向对象
-
面向对象(Object-Oriented)
- ooa:面向对象的分析
- ood:面向对象的设计
- oop:面向对象的编程
-
面向对象三大特性
- 封装，继承，多态
2.1类和对象关系
-
类：一种数据类型，引用数据类型，自定义的一种类型，用变量表示属性，用方法表示行为
-
对象:具体存在的事务，符合类的定义特征.
-
类的定义个数：
class 类名[] -
如何创建对象
类名 对象名 = new 类名(); -
demo1:创建一个学生类定义姓名，性别，分数，定义一个方法study添加一个自我介绍的方法。
// StudentDemo package obj; public class Student { String name; int age; double score; // 定义方法 public void teach() { System.out.println("姓名：" + this.name); } } // TestDemo package obj; public class StudentDemo { public static void main(String[] args) { Student std = new Student(); std.name = "小明"; std.age = 12; std.score = 80; System.out.println(std);// obj.Student@4c203ea1 System.out.println(std.name);// 小明 std.teach();// 姓名：小明 } }
2.2组件介绍
- 成员变量，静态变量，局部变量，成员方法，静态方法，构造方法
package obj;
public class Student {
// 成员变量
String name;
int age;
double score;
// 静态变量
static int a;
// 成员方法
public void teach() {
System.out.println("姓名：" + this.name);
}
// 静态方法
public static void test(int x, int y) {
int abc = 100;//局部变量
}
// 构造方法
public Student(String name , int age) {
this.name = name;
this.age = age;
}
}
- 六大组件总结
成员变量： 类中方法外，没有static修饰，存放在堆内存中，有初始值，随着对象的创建而产生，随着对象的消失而消失。
静态变量： 类中的方法外，有static修饰，存放在方法区的静态区，有初始值，随着类的加载而加载，随着类的消失而消失
局部变量： 定义在方法中或方法的参数列表上，存在栈内存中，没有初始值，随着方法的调用而创建，随着方法的结束而消失。
成员方法：没有static修饰的方法，使用对象调用。
静态方法：有static修饰的方法，使用类名调用
构造方法： 方法名和类名相同，没有返回值。使用new 关键字创建对象的时候调用。
2.3面向对象内存分配
// 解析
当我们创建一个类时候，首先会在堆空间方法去创建class区和static区。class区保存定义的类，static保存静态方法。当我们对类进行初始化，class区将成员变量初始化并拷贝到堆内存地址中，初始化变量指向类方法内定义成员变量的地址。
2.4成员变量和局部变量区别
- 成员变量:定义在类中方法外，没有static修饰，存储在堆内存中，有初始值，随着对象的消失而消失。
- 局部变量：定义在方法中或者方法的参数列表上，存储在栈内存中，没有初始值，随着方法的调用而产生，随着方法的结束而消失。
2.5 封装
-
封装前需要使用成员变量:private. 此为权限修饰符，当然权限修饰符还有:public,protected,default,private。
-
而private表示私有的，它可以修饰方法和变量，被private修饰符方法和变量，只能在本类种访问:
-
提供一套访问的修饰方法get和set方法。
-
demo
// Teacher类
package func;
public class Teacher {
private String name;
private int age;
private int gender;
private double salary;
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 int getGender() {
return gender;
}
public void setGender(int gender) {
this.gender = gender;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public void show() {
System.out.println("name:" + name + "age:"+ age+ "gender:" + gender + "salary:" + salary);
}
}
// 调用封装Teacher类
package func;
public class TeacherDemo {
public static void main(String[] args) {
Teacher t = new Teacher();
t.setName("张三");
t.setAge(18);
t.setGender(1);
t.setSalary(1235.3);
t.show();
}
}
- 封装练习
package func;
public class Mobile {
private String brand;
private String type;
private double price;
private String color;
public void setBrand(String brand) {
this.brand = brand;
}
public void setType(String type) {
this.type = type;
}
public void setPrice(double price) {
this.price = price;
}
public void setColor(String color) {
this.color = color;
}
public String getBrand() {
return brand;
}
public String getType() {
return type;
}
public double getPrice() {
return price;
}
public String getColor() {
return color;
}
public void show() {
System.out.println("brand:"+brand+"color:"+color+"type:"+type+"price:"+price);
}
}
package func;
public class MobileDemo {
public static void main(String[] args) {
Mobile m1 = new Mobile();
m1.setBrand("华为");
m1.setColor("红色");
m1.setType("5G");
m1.setPrice(2399.5);
Mobile m2 = new Mobile();
m2.setBrand("苹果");
m2.setColor("黄色");
m2.setType("X");
m2.setPrice(4399.5);
Mobile[] ms = new Mobile[] {m1, m2};
for (int i=0;i<ms.length;i++) {
ms[i].show();
}
}
}
- 练习求长方形周长和面积
package func;
public class Rect {
private double length;
private double width;
public void setLength(double length) {
this.length = length;
}
public void setWidth(double width) {
this.width = width;
}
public double periMeter() {
return 2*(this.length+this.width);
}
public double area() {
return this.length*this.width;
}
}
package func;
public class RectDemo {
public static void main(String[] args) {
Rect r = new Rect();
r.setLength(10);
r.setWidth(5);
double perimeter = r.periMeter();
double area = r.area();
System.out.println(perimeter);// 30.0
System.out.println(area);// 50.0
}
}
2.6构造方法
- 当new的时候，构造方法被调用，构造方法没有返回值，构造方法名与类名相同，构造方法可以被重载（一个类中可以存在多个名字相同的方法，但是必须保证参数的个数或类型不同，与返回值无关）。
- 如果我们没有在类种写构造方法，系统会默认为我们生成一个无参数的构造方法，如果我们写了构造方法，则系统不会为我们生成默认构造方法。
package gouzao;
public class Teacher {
private String name;
private int age;
private double salary;
public Teacher(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public void show() {
System.out.println("name:"+name+"age:"+age+"salary:"+salary);
}
}
package gouzao;
public class TeacherDemo {
public static void main(String[] args) {
Teacher t = new Teacher("Tom",20,25002.3);
t.show();
}
}
- 生成get/set无参数方法：eclipse-->右键--->Source--->Generate getters nad setters
2.7类的三种赋值方式：
1.
Product p1 = new Product();
p1.proId = "001";
p1.proName = "毛巾";
p1.proPrice = 1234;
p1.proNum = 90;
2.
Product p2 = new Product();
p2.setProId("002");
p2.setProName("馒头");
p2.setProPrice(10);
p2.setProNum(70);
3.
Product p3 = new Product("003", "袜子", 10, 20);
2.7同名局部变量和成员变量的区分
package demo;
public class Person {
// 成员变量
String name = "张三";
// 方法的重载:
public void print() {
System.out.println(name);
}
public void print(String name) {// 就近原则调用name
System.out.println(name);
}
public void print1(String name) {
System.out.println(this.name);
}
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.name);// 张三
p.name = "李四";
p.print();// 李四
p.print("老刘");// 老刘
p.print1("小明");// 李四
}
}
2.8 static关键字
- 类中成员方法和成员变量使用对象调用，类中的静态方法和静态变量使用类名调用。类中构造方法是使用new关键字创建对象调用。
package demo;
public class Student {
String name;
int age;
public Student(int a) {
System.out.println(a);
}
public void study() {
System.out.println("好好学习天天向上!");
}
public static void test() {
System.out.println("test 静态方法！");
}
}
package demo;
public class StudentDemo {
public static void main(String[] args) {
// 构造方法通过new调用
Student s = new Student(123);
// 成员方法，成员方法用类对象.方法
s.study();
// 静态方法用类.方法调用
Student.test();
new Stidemt(777).study();// 匿名对象，只用于调用1次情况下
// 局部变量只能在方法中使用.
}
}
- 静态方法无法使用成员变量，只能调用静态变量。
因为成员变量是通过new对象才能产生，而调用静态方法，没有new对象，所以无法调用
- 静态变量与非静态变量区别
成员变量可以理解为，每当你new一个对象都会在堆中新生成一个或多个新的成员变量。
静态变量，相当于所有对象都共用这一套静态变量，它属于类的。
2.9代码块
-
静态代码块:static{}
执行周期:随着类的加载而执行一次- demo
package demo; public class CodeBlockDemo { static { System.out.println("打印静态代码块"); } public static void main(String[] args) { } } -
构造代码块:{}
每new 关键字创建一个对象，就会执行一次- demo
{ System.out.println("构造代码块"); } public static void main(String[] args) { CodeBlockDemo c1 = new CodeBlockDemo(); CodeBlockDemo c2 = new CodeBlockDemo(); } // 构造代码块 // 构造代码块 -
构造方法代码块:
public class CodeBlockDemo { static { System.out.println("打印静态代码块"); } { System.out.println("构造代码块"); } public CodeBlockDemo() { System.out.println("构造方法代码块"); } public static void main(String[] args) { CodeBlockDemo c1 = new CodeBlockDemo(); CodeBlockDemo c2 = new CodeBlockDemo(); } } // 打印静态代码块 // 构造代码块 // 构造方法代码块 // 构造代码块 // 构造方法代码块- 由上面可以看出:静态代码块 先于 构造代码块 先于 构造方法。
-
局部代码块
- 定义在方法中的代码块，运行完后立刻释放。
package demo; public class CodeBlockDemo { public void show() { { System.out.println("局部代码块"); } } public static void main(String[] args) { new CodeBlockDemo().show(); } } -
练习：统计创建对象的总个数:
package demo; public class CodeBlockDemo { static int count = 0; static { System.out.println("打印静态代码块"); } { count++; System.out.println("构造代码块"); } public CodeBlockDemo() { System.out.println("构造方法代码块"); } public void show() { { System.out.println("局部代码块"); } } public static void main(String[] args) { CodeBlockDemo c1 = new CodeBlockDemo(); CodeBlockDemo c2 = new CodeBlockDemo(); new CodeBlockDemo().show(); System.out.println(count);// 3 } }