重载:
同类同方法不同参数
构造:
概念
与类同名,且没有返回值类型,可以含参也可以不含参
特性
如果提供其他的构造函数,默认的无参构造会被覆盖
每次创建对象时,都会执行构造方法
每一个类中都默认有一个没有参数的构造方法,每次new对象时,都会自动触发这个类对应的构造方法
作用
用于创建对象
package cn.tedu.oop;
/*本类用于测试构造方法*/
public class TestConstructor {
public static void main(String[] args) {
/*每一个类中都默认有一个没有参数的构造方法
* 每次new对象时,都会自动触发这个类对应的构造方法*/
Persion p=new Persion();
System.out.println(p.name);
System.out.println(p.age);
System.out.println(p.address);
p.eat();
Persion p2=new Persion();
Persion p3=new Persion("李白");
Persion p4=new Persion("李逵",32,"柳树下");
System.out.println(p4.name);
System.out.println(p4.age);
System.out.println(p4.address);
System.out.println(p3.name);
}
}
class Persion{
String name;
int age;
String address;
public Persion(){
System.out.println("我是persion类的无参构造");
}
//无参构造
public void eat(){
System.out.println("干饭不积极,思想有问题~");
}
public Persion(String name){
this.name=name;
System.out.println("我是persion的含参构造");
}
//全参构造方法
public Persion(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
System.out.println("我是persion的全参构造");
}
}
运行结果:
我是persion类的无参构造
null
0
null
干饭不积极,思想有问题~
我是persion类的无参构造
我是persion的含参构造
我是persion的全参构造
李逵
32
柳树下
李白
构造代码块:{}
位置:类里方法外
执行时间:每次创建对象时都会执行构造代码块,且优先构造方法执行
作用:用于提取所有构造方法的共性功能
package cn.tedu;
/*本类用于测试代码块*/
public class TestBlock {
public static void main(String[] args) {
//System.out.println("666");
Pig p1=new Pig();
Pig p2=new Pig("好");
Pig p3=new Pig("菜",6);
}
}
class Pig{
String food;
int age;
{
System.out.println("我是构造代码块");
}
public Pig(){
System.out.println("我是无参构造");
}
public Pig(String food){
System.out.println("我是含参构造"+food);
}
public Pig(String food,int age){
this.age=age;
this.food=food;
System.out.println("我是全参构造");
}
public void eat(){
System.out.println("小猪爱吃菜叶子");
}
}
执行结果:
我是构造代码块
我是无参构造
我是构造代码块
我是含参构造好
我是构造代码块
我是全参构造
局部代码块:{}
位置:类里方法里
执行时间:调用局部代码块所处的方法时执行
作用:用于控制变量的作用范围,变量的作用范围越小越好
package cn.tedu;
/*本类用于测试代码块*/
public class TestBlock {
public static void main(String[] args) {
//System.out.println("666");
Pig p1=new Pig();
Pig p2=new Pig("好");
Pig p3=new Pig("菜",6);
p1.eat();
}
}
class Pig{
String food;
int age;
{
System.out.println("我是构造代码块");
}
public Pig(){
System.out.println("我是无参构造");
}
public Pig(String food){
System.out.println("我是含参构造"+food);
}
public Pig(String food,int age){
this.age=age;
this.food=food;
System.out.println("我是全参构造");
}
public void eat(){
System.out.println("小猪爱吃菜叶子");
{
System.out.println("我是一个局部代码块");
}
}
}
运行结果:
我是构造代码块
我是无参构造
我是构造代码块
我是含参构造好
我是构造代码块
我是全参构造
小猪爱吃菜叶子
我是一个局部代码块
this关键字
1.当成员变量和局部变量同名时,可以使用this关键字指定本类的成员变量
package cn.tedu.oop2;
/*本类测试this*/
public class TestThis {
public static void main(String[] args) {
Dog d=new Dog();
d.eat();
}
}
class Dog{
int count=666;
int sum=100;
public void eat(){
int sum=10;
System.out.println(sum);
System.out.println(count);
System.out.println(this.sum);
}
}
执行结果:
10
666
100
2.在含参构造函数中调用无参构造函数,且必须写在第一行
package cn.tedu.oop2;
/*用来测试this*/
public class TestThis2 {
public static void main(String[] args) {
cat c1=new cat();
cat c2=new cat("下午好");
}
}
class cat{
public cat(){
this("你好");
System.out.println("小猫的无参构造");
}
public cat(String s){
//this();
System.out.println("小猫的含参构造"+s);
}
}
执行结果:
小猫的含参构造你好
小猫的无参构造
小猫的含参构造下午好
继承(extends)
java只能单继承,一个子类不可以有多个父类,但一个父类可以有多个子类
子类继承父类后,不能继承父类的私有资源
super
当父类的成员变量和子类的成员变量同名时,可以使用super关键字指定父类的成员变量
package cn.tedu.oop2;
//用于测试继承中变量的使用
public class TestExtends1 {
public static void main(String[] args) {
Son s=new Son();
s.study();
System.out.println(s.count);
}
}
class Father{
int sum=1;
int count=2;
}
class Son extends Father{
int sum=10;
public void study(){
System.out.println("good good study,day day up");
int sum=100;
//打印子类的局部变量sum
System.out.println(sum);
//打印子类的成语变量sum
System.out.println(this.sum);
System.out.println(super.sum);
}
}
执行结果:
good good study,day day up
100
10
1
2
子类在创建对象时,默认会先调用父类的构造函数
子类必须调用父类的构造方法,不论是无参还是含参
package cn.tedu.oop2;
//本类用于测试继承中的构造方法
public class TestExtends {
public static void main(String[] args) {
Son2 s=new Son2();
}
}
class Father2{
public Father2(){
System.out.println("我是父类的无参构造");
}
public Father2(String s){
System.out.println("我是父类的含参构造"+s);
}
}
class Son2 extends Father2{
public Son2(){
super();
System.out.println("我是子类的无参构造");
}
}
执行结果:
我是父类的无参构造
我是子类的无参构造
重点
创建对象的同时就已经调用了构造方法
super:1.作用于不同类,子类与父类成员变量同名时,子类可以通过super.调用父类的成员变量
package cn.tedu.oop2;
//用于测试继承中变量的使用
public class TestExtends1 {
public static void main(String[] args) {
Son s=new Son();
s.study();
}
}
class Father {
int sum = 1;
}
class Son extends Father{
int sum=10;
public void study(){
int sum=100;
System.out.println(sum);
System.out.println(super.sum);
}
}
运行结果:
100
1
2.作用于不同类中,子类可以通过super()调用父类的无参构造,也可以通过super(参数)调用父类的含参构造方法
package cn.tedu.oop2;
//本类用于测试继承中的构造方法
public class TestExtends {
public static void main(String[] args) {
Son2 s=new Son2();
}
}
class Father2{
public Father2(){
System.out.println("我是父类的无参构造");
}
public Father2(String s){
System.out.println("我是父类的含参构造"+s);
}
}
class Son2 extends Father2{
public Son2(){
super("哈哈");
System.out.println("我是子类的无参构造");
}
}
运行结果:
我是父类的含参构造哈哈
我是子类的无参构造
3.子类在创建对象时,默认会调用父类的方法,因为子类的构造函数中的第一行默认存在super()
package cn.tedu.oop2;
//本类用于测试继承中的构造方法
public class TestExtends {
public static void main(String[] args) {
Son2 s=new Son2();
}
}
class Father2{
public Father2(){
System.out.println("我是父类的无参构造");
}
}
class Son2 extends Father2{
public Son2(){
System.out.println("我是子类的无参构造");
}
}
运行结果:
我是父类的无参构造
我是子类的无参构造