review
package cn.tedu.review;
/*本类用于复习面向对象案例*/
public class TestPhone {
public static void main(String[] args) {
//4.创建手机类对象测试
Phone p1 = new Phone();
//5.
p1.setBrand("banana");
p1.setColor("石墨黑");
p1.setSize(4.5);
p1.setPrice(999);
//6.查看p1
System.out.println(p1.getBrand());
System.out.println(p1.getColor());
System.out.println(p1.getPrice());
System.out.println(p1.getSize());
//7.创建手机类的第二个对象
Phone p2 = new Phone();
//8.调用手机类的功能
p2.music();
//p2.message();//不可以直接调用发短信的功能,因为私有方法只能在本类使用
p2.video();
}
}
//1.创建手机类
class Phone{
//2.创建手机类的属性
private String brand;
private double size;
private double price;
private String color;
//3.创建方法
public void music(){
System.out.println("正在听音乐");
message();
}
private void message(){
System.out.println("正在发短信");
}
public void video(){
System.out.println("正在看直播");
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getSize() {
return size;
}
public void setSize(double size) {
this.size = size;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
构造函数
1.构造函数:
格式:与本类类名同名,且没有返回值类型
作用:创建对象,创建一次,执行一次构造函数
分类:
1)无参构造:默认存在,如果添加了其他构造,默认的构造函数会被覆盖
2)含参构造:对于参数没有任何要求,有参数就行
3)全参构造:全参构造的参数必须与本类属性一致
全参构造不仅可以创建对象,还可以给对象的所有属性赋值
2.构造代码块:
1)位置:类里方法外
2)执行时机:每次创建对象时执行,并且优先于构造方法执行
3)作用:用于提取所有构造方法的共性功能
3.局部代码块:
1)位置:方法里
2)执行时机:调用本局部代码块所处的方法时执行
3)作用:用于控制变量的作用范围
package cntedu.oop;
/*本类用作构造函数的入门案例*/
public class TestConstructor {
public static void main(String[] args) {
//4.
/*1.每次new对象时,都会自动触发对应类中的构造方法
* 2.每一个类中都会默认存在一个没有参数的构造方法
* 但是你提供了其他的构造函数,默认的无参构造会被覆盖掉
* 所以,我们要手动提供无参构造,这样才能不传参数,也能创建对象
* */
Person p1 = new Person();
System.out.println(p1.name);
System.out.println(p1.age);
System.out.println(p1.address);
p1.eat();
/*4.每次创建对象,都会执行一个构造方法
* 构造方法的作用:用来创建对象的*/
Person p2 = new Person(500);
System.out.println(p2.name);
/*5.全参构造不仅可以创建对象,还可以给对象的所有属性赋值*/
Person p3 = new Person("李逵",18,"柳树下");
System.out.println(p3.name);
System.out.println(p3.age);
System.out.println(p3.address);
}
}
//1.创建类
class Person{
//2.
String name;
int age;
String address;
/*3.构造方法的格式:与本类类名同名且没有返回值类型的方法*/
//5.创建本类的无参构造
public Person(){
System.out.println("我是Person类的无参构造");
}
//5.2创建本类的含参构造--含有参数的构造方法
public Person(int n){
System.out.println("我是Person类的含参构造" + n);
}
//5.3创建本类的全参构造--此构造函数的参数与本类的属性一致
public Person(String name, int age, String address) {
System.out.println("我是Person类的全参构造");
this.name = name;
this.age = age;
this.address = address;
}
//3.功能--方法
public void eat(){
System.out.println("端起了我的饭盆");
}
}
package cn.tedu.oop;
/*本类用于测试代码块
* 执行顺序:构造代码块 -> 构造方法 -> 普通方法 -> 局部代码块,分析
* 1.当创建对象时,会触发构造函数
* 2.创建对象时,也会触发构造代码块,并且构造代码块优先于构造方法执行
* 3.我们创建好对象后才能通过对象调用普通方法
* 4.如果普通方法里有局部代码块,才会触发对应的局部代码块
* */
public class TestBlock {
public static void main(String[] args) {
System.out.println("今天的你真好看");
Pig p1 = new Pig();
Pig p2 = new Pig("佩奇");
Pig p3 = new Pig("肉包子",10);
System.out.println(p2.age);
System.out.println(p3.age);
p1.eat();
p2.eat();
p3.eat();
}
}
//1.
class Pig{
String food;
int age;
//7.创建本类的构造代码块
{
/*构造代码块:{}
* 1.位置:类里方法外
* 2.执行时机:每次创建对象时都会执行构造代码块,并且构造代码块先于构造方法执行
* 3.作用:用于提取所有构造方法的共性功能*/
System.out.println("我是一个构造代码块");
System.out.println("黑猪!");
}
//4.1无参构造
public Pig(){
System.out.println("我是Pig类无参构造");
}
//4.2含参构造
public Pig(String s){
System.out.println("我是Pig类含参构造" + s);
}
//4.3全参构造
public Pig(String food, int age) {
System.out.println("我是Pig类全参构造");
this.food = food;
this.age = age;
}
//3.
public void eat() {
System.out.println("小猪爱吃菜叶子");
//8.创建本类的局部代码块
{
/*局部代码快:{}
1.位置:方法里
2.执行时机:调用本局部代码块所处的方法时才会执行
3.作用:用于控制变量的作用范围,变量的作用范围越小越好
*/
System.out.println("我是一个局部代码块");
int i = 100;
System.out.println(i);
}
//System.out.println(i);//局部代码快中的变量i只能在代码块里使用
}
}
this
this的用法:
1.当成员变量与局部变量同名时,使用this指定成员变量
2.使用this在构造方法的第一行调用构造方法的功能
this();–调用的是本类的无参构造
this(参数);–调用的是本类对应参数的构造方法
package cn.tedu.oop;
/*本类用于this测试*/
public class TestThis1 {
public static void main(String[] args) {
//4.创建对象并调用方法
Cat c = new Cat();
c.eat();
}
}
//1.创建小猫类
class Cat{
//5.创建一个成员变量
int count = 666;
int sum = 100;
//2.创建方法
public void eat(){
//3.创建局部变量
int sum = 10;
System.out.println(sum);
/*当成员变量余额局部变量同名时,可以使用this指定本类的成员变量
如果不使用this指定,打印的就是近处的这个局部变量,就近原则*/
System.out.println(this.sum);
System.out.println(count);
}
}
package cn.tedu.oop;
/*本类用于测试this的用法2*/
public class TestThis2 {
public static void main(String[] args) {
Dog d1 = new Dog();
//Dog d2 = new Dog("旺财");
}
}
class Dog{
public Dog(){
/*在无参构造中调用含参构造的功能
* 注意:调用是单向的,不能来回双向调用,否则会是循环*/
this("小旺旺");
System.out.println("无参构造");
}
public Dog(String s){
/*在含参构造中调用无参构造
* 规定:this关键字必须在构造函数的第1行*/
//this();
System.out.println("含参构造"+s);
}
}
package cn.tedu.oop;
/*本类用于oop综合练习*/
public class TestTeacher {
public static void main(String[] args) {
//5.1
Teacher t1 = new Teacher();
//5.2
Teacher t2 = new Teacher(10);
//5.3
Teacher t3 = new Teacher("paopao",'女',20,99999.99);
System.out.println(t3.getName()+t3.getAge()+t3.getGender()+t3.getSalary());
//6.1
t1.setName("孙悟空");
t1.setAge(11);
t1.setGender('男');
t1.setSalary(100);
System.out.println(t1.getGender()+t1.getName()+t1.getAge()+t1.getSalary());
}
}
class Teacher{
private String name;
private char gender;//性别
private int age;
private double salary;
public Teacher(){
System.out.println("无参构造");
}
public Teacher(int n){
System.out.println("含参构造"+n);
}
public Teacher(String name, char gender, int age, double salary) {
this.name = name;
this.gender = gender;
this.age = age;
this.salary = salary;
System.out.println("全参构造");
}
public String ready(){
System.out.println("正在备课中·····");
return "产出课程+1";
}
public void teach(String subject){
System.out.println("正在授课:"+subject);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
super
super的用法:
1.当父类的成员变量与子类的成员变量同名时,使用super指定父亲的成员变量
2.使用super在子类构造方法的第一行调用父类构造方法的功能
super();–调用的是父类的无参构造
super(参数);–调用的是父类对应参数的构造方法