复习
1.面向过程
2.面向对象
3.类 指一类事物 抽象的
4.对象 根据类创建出来的具体实例
一个类可以创建多个对象，对象通过地址值区分
5.对象创建过程分析
目录
1.面向对象
1.1封装
（我们可以把一类事物的属性与功能封装到一个类组件中）
1）用private修饰属性，只能本类使用，外界无法访问，为了让外界按照我们提供的方法来调用，需要根据属性生成公共的set()、get()方法
2）用private修饰方法，在本类公共方法里调用此私有方法
一个java文件中可以创建多个class，但是被public修饰的类只能有一个，并且这个java文件的名字必须与此公共类名字一致
知识点
访问控制符
修饰符：public protected 默认 private
练习1：学生
package cn.tedu.oop;
/**本类用于测试封装*/
/**一个java文件中可以创建多个class，但是被public修饰的类只能有一个
* 并且这个java文件的名字必须与此公共类名字一致*/
public class TestPrivate {
public static void main(String[] args) {
Student a=new Student();
// a.name="张丹";
// System.out.println(a.name);
// a.eat();
a.setName("张三");
System.out.println(a.getName());
a.study();
}
}
/**我们可以把一类事物的属性与功能封装到一个类组件中
* 为了提高程序的安全性以及调用，
* 要按照我们指定的方式来调用
* 所以我们可以封装自定义类中的属性和方法*/
class Student{//准备学生这类模板 驼峰
private String name;//成员变量定义属性
/**添加被封装属性的公共的get与set方法
* 也就是对外提供公共的属性值获取/设置方式
* 右键→source→Generate→Getters and Setters*/
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
int sno;//学号
/**封装属性：在属性前+private
* 被private修饰的资源只能在本类中使用*/
String subject;
public void study() {
System.out.println("学习");
/**方法封装2：在本类的公共方法里访问私有方法的功能*/
eat();
}
/**方法的封装1：将方法的访问控制符改成private*/
private void eat() {
System.out.println("吃");
}
}练习2：小汽车
package cn.tedu.oop;
/**本类用于面向对象巩固练习*/
public class TestCar {
public static void main(String[] args) {
//6.创建对象并测试
Car a=new Car();
a.setColor("黑色");
a.setBrand("宝马");
System.out.println(a.getColor());
System.out.println(a.getBrand());
a.start();
}
}
//1.定义汽车类
class Car{
//2.定义属性
private String color;
private String brand;
private double price;
private double length;
//3.定义方法
public void start() {
System.out.println("我的车启动");
//5.2在公共方法里调用
stop();
}
//5.1封装方法
private void stop() {
System.out.println("我的车熄火");
}
//4.封装属性
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
}2.构造方法
2.1概念
格式：与类同名且没有返回值类型的方法
功能：就是完成对象创建或者初始化（每次new(实例化)对象时都会自动调用构造方法→被动执行）
特点：①每个类会默认提供一个本类的无参构造（一个类中默认存在无参构造，但是如果自定义了其他的构造方法
* 默认的无参构造会被覆盖）
②构造方法也存在重载的现象（无参/含参/全参）
注意：①通过方法名（参数列表）来调用方法
②全参构造不仅可以创建对象还可以给创建出来的属性赋值
知识点：方法的重载
同一个类中存在多个方法名相同但参数列表不同（参数个数、参数类型，与参数名无关）的现象
注意：1.为了使用时传入不同的参数，也可以很好地匹配到同名的方法来执行此功能
2.如果在同类中，同名方法的参数个数不同，那么一定构成重载
3.如果在同类中，同名方法的参数个数相同，可能构成重载4.如果参数个数相同，需要依次比对每个位置上参数的类型
(int a,String b)与(int b,String a)--不构成重载
(String a,int b)与(int a, String b)--构成重载
2.2类型
1）无参构造 默认创造无参构造
public Person() {
System.out.println("我是Person类的无参构造");
}2）含参构造
3）全参构造（全参构造既可以创建对象又可以直接赋值 一步到位）
package cn.tedu.oop;
/**本类用作构造函数的入门案例*/
public class TestConstructor {
public static void main(String[] args) {
//4、创对象 测试
/**1.一个类会默认存在无参构造，
* 每次new(实例化)对象时都会自动调用构造方法→被动执行*/
Person p=new Person();
//含参构造
Person p1=new Person("李四");
//全参构造既可以创建对象又可以直接赋值 一步到位
Person p2=new Person("李四",25,"山东");
System.out.println(p.age);
p.eat();
System.out.println(p2.age);
}
}
//1、创建类用于描述人
class Person{
//2、定义属性
String name;
int age;
String address;
//5、创建Person类的无参构造
/**2.构造方法的格式：与类同名且没有返回值类型的方法*/
public Person() {
System.out.println("我是Person类的无参构造");
}
/**3.方法的重载：在同一个类中存在多个方法，
* 方法名相同但参数列表不同的现象*/
/**4.构造函数也存在重载的现象*/
//自动生成全参构造
public Person(String name) {
System.out.println("我是Person类的含参构造"+name);
}
public Person(String name, int age, String address) {/**形参*/
super();
System.out.println("我是全参构造");
this.name = name;
this.age = age;
this.address = address;
}
//3、定义功能
public void eat() {
System.out.println("吃饭吧");
}
}拓展：形参（无实际值）、实参（有实际值）
例：方法参数列表中的参数名为形参
3.构造代码块与局部代码块
3.1形式
{ }
3.2构造代码块
位置：类里方法外
每次创建对象时都会执行一次构造代码块
执行时机：每次在调用构造方法时触发，而且要优先于构造方法执行
作用：用于提取所有构造方法的共性功能
3.3局部代码块
位置：方法里
执行时机：调用本代码块所在的方法时才会触发
作用：控制变量的作用范围，越小越好
顺序：
* 构造代码块→构造方法→对象创建成功→局部代码块原因：
1.创建对象时，程序会自动调用构造方法，但是如果有构造代码块会先执行构造代码块提取所有构造的共性功能，再执行构造方法的创建对象
2.对象创建好后就可以通过对象来调用方法，如果方法中有局部代码块
就执行对应的局部代码块
练习：
package cn.tedu.block;
/**本类用于代码块的入门案例*/
/**顺序：
* 构造代码块→构造方法→对象创建成功→局部代码块*/
/**1.创建对象时，程序会自动调用构造方法，但是如果有构造代码块
* 会先执行构造代码块提取所有构造的共性功能，再执行构造方法的创建对象
* 2.对象创建好后就可以通过对象来调用方法，如果方法中有局部代码块
* 就执行对应的局部代码块*/
public class TestBlock {
public static void main(String[] args) {
/**每次创建对象时都会执行一次构造代码块*/
Teacher a=new Teacher();
Teacher t=new Teacher();
a.teach();
Teacher b=new Teacher("CGB");
}
}
//1.定义老师类
class Teacher{
// 2.定义属性
String subject;
//定义构造代码块
/**构造代码块：
* 位置：类里方法外
* 执行时机：每次在调用构造方法时触发，而且要优先于构造方法执行
* 作用：用于提取所有构造方法的共性功能*/
{
subject="java";
System.out.println("我是构造代码块");
}
//3.
public Teacher() {
System.out.println("T的无参构造"+subject);
}
//如果我们有多个构造方法被构造代码块提取了共性内容
// 但是有个别的构造方法需要自定义参数，这个时候可以把此参数名设置为方法的参数
// 那么调用方法时，传什么值，就是什么值
public Teacher(String subject) {//此条打印赋值的值
System.out.println("T的含参构造"+subject);
}
public void teach() {
System.out.println("授课");
/**局部代码块：
* 位置：方法里
* 执行时机：调用本代码块所在的方法时才会触发
* 作用：控制变量的作用范围，越小越好*/
{
System.out.println("我是局部代码块");
}
}
}4. this
4.1概念
代表一个本类对象
4.2形式
this.name=name;
1）成员变量与局部变量同名时，我们可以通过this关键字来指定成员变量， 因为成员变量属于类资源
package cn.tedu.block;
/**本类用于测试this的第一个用法*/
public class TestThis1 {
public static void main(String[] args) {
Cat a=new Cat();//创建对象
a.eat();
}
}
//创建小猫类
class Cat{
//定义成员变量
int sum=20;
int s=30;
//定义普通方法
public void eat() {
int sum=10;//局部变量
System.out.println(sum);//变量的就近原则
System.out.println(s);
/**当成员变量与局部变量同名时，
* 我们可以通过this关键字来指定成员变量
* 因为成员变量属于类资源*/
System.out.println(this.sum);
}
}2）调用方法
this可以实现构造方法的调用
注意：是单方向的，不能来回调用
this();--调用本类无参构造
this(参数);--调用本类含参构造
package cn.tedu.block;
/**测试this用法2*/
public class TestThis2 {
public static void main(String[] args) {
Dog a=new Dog();
Dog a1=new Dog(45);
// a.Dog();会报错，不能主动在外部调用构造方法
}
}
/**this可以实现构造方法的调用
* 注意：是单方向的，不能来回调用
* this();--调用本类无参构造
* this(参数);--调用本类含参构造*/
class Dog{
public Dog() {
/**↓在无参构造中调用本类含参构造*/
// this(456);
System.out.println("无参");
}
public Dog(int n) {
/**↓在含参构造中调用本类无参构造 两处调用不能同时使用*/
this();
System.out.println("含参"+n);
}
}