构造器
1.构造器
含义:在类中用来创建对象的方法,是一个特殊的方法
作用:用来创建对象
注意事项:
a.方法名称和类名相同
b.方法无返回值
c.在方法中无需显示return返回数据
d.构造器方法是允许重载的
e.所有类默认情况下都会存在一个无参构造器,如果在当前类中显式声明了构造器之后,无参构造器就不存在了
当给一个类中的成员变量的类型声明为基本数据类型,导致基本数据类型存在默认值。
public class Student {
static int count = 1;
int id;
String name;
int gender;// 0 代表男 1代表女
String clz;
public Student() {
this("张三");
System.out.println("我被调用了。。。。");
//study();
}
public Student(String name) {
this.name = name;
}
public Student(String name,int gender) {
this(name,gender,count++,"0708");
}
public Student(String name,int gender,int id,String clz) {
this.name = name;
this.gender = gender;
this.id = id;
this.clz = clz;
}
public void study() {
System.out.println(this.name+"day day up");
System.out.println(this.info());
}
public String info() {
return "Student[id:"+this.id+",name:"+this.name+"" + ",gender:"+(this.gender==0?"男":"女")+",clz:"+this.clz+"]";
}
}
}
2.this
含义:this表示一个对象的引用,它指向正在执行方法的对象. 特别的, 在构造方法中,通过this关键字调用其他构造方法时,必须放在第一行,否则编译器会报错. 且在构造方法中, 只能通过this调用一次其他构造方法.
用法:this.和this()
this.
调用当前对象。一般可省略this.
不可省略:
区分同名变量,局部变量和成员变量
this()
用于构造器之间的互相调用
this()一定要放在构造器的首行
3.引用类型经过方法
1.基本数据类型经过方法之后,其值不变。值传递
2.引用数据类型经过方法之后,其值会变,值传递(地址值)
3.通过两个变量指向了同一个内存地址,一个对内存进行改变,另一个可见
4.继承
含义:将多个类中的共性再一次抽取为一个父类。父类的作用就是用来将一些重复的内容不再多次编写(提高代码复用性)。
注意事项:
1.java中只支持单继承,一个子类有且只有一个父类。因此复用性的提高是有限的。
2.单继承和多继承:
单继承:代码调用的复杂程度比较低,但复用性比较有限
多继承:极大提高代码复用性,但是代码调用的复杂度也提高了
结构:
子类 extends 父类 (子类拥有父类的所有属性和方法)
代码:
public class Person {
String name;
int age;
int gender;
public Person() {
}
public void eat() {
System.out.println(this.name+"在吃饭");
}
public class Student extends Person{
int id;
public Student() {
}
}
}
public void study() {
System.out.println(this.name+"在学习");
}
} public class Teacher extends Person{
double sal;
public Teacher() {
}
public void working() {
System.out.println(this.name+"在工作");
}
}
public class Test {
public static void main(String[] args) {
//创建一个学生对象
Student stu = new Student();
stu.name = "小鱼鱼";
stu.eat();
stu.study();
//创建一个老师对象
Teacher t = new Teacher();
t.name = "憨憨";
t.sal = 1000000000;
t.eat();
t.working();
}
}
5.super
当创建子类对象时,会先执行父类的构造器
作用:是指向自己父类对象的一个指针,而这个父类指的是离自己最近的一个父类。
用法:
super.
当子类和父类中出现了同名变量或者同名方法
super()
1.调用父类的构造器,默认情况下调用的父类的无参构造器(默认情况下,哪怕不写都存在)
2.当父类存在其他构造器时,无参构造器不存在,此时如果在子类中没有通过super()显示的指定调用的构造器会导致程序报错
3.在构造器中,this()和super()不能同时出现,如果两个都不存在,默认是存在的super()。
代码:
public class Test01 {
public static void main(String[] args) {
// 创建一个子类对象
Dog d = new Dog();
//d.lookDoor();
}
}
class Animal{
String name;
public Animal() {
System.out.println(" Animal 我被调用了.......");
}
public Animal(String name) {
this.name = name;
System.out.println(" Animal 带参构造器 我被调用了.......");
}
public void eat() {
System.out.println("animal 吃东西");
}
}
class Dog extends Animal{
String nickName;
public Dog() {
this("呵呵");
System.out.println(" DOG 我被调用了。。。");
}
public Dog(String nickName) {
//super("hehe");
this.nickName = nickName;
System.out.println("DOG 才参数的");
}
public void lookDoor() {
System.out.println("看门");
super.eat();
}
public void eat() {
System.out.println("dog 吃东西");
}
}
Dog d=new Dog();
6.方法重写
含义: 在子类中定义了和父类同名的方法,将该方法称之为重写方法(覆盖)。
原因:父类的功能不能满足子类的需求。子类需要在父类的基础上进行扩展。
如何确定是重写:
在子类的方法上加入@overried 注解 如果不报错,证明是重写
重写前提:
1.一定要发生继承关系,且子类的方法名和父类的方法名同名
2.参数列表一样
3.返回类型一样
public class Test01 {
public static void main(String[] args) {
//创建一个子类对象
S s = new S();
s.study();
s.marry();
s.work();
}
}
class F{
String name;
public F() {
}
public int study() {
System.out.println("好好学习 ");
return 1;
}
public void marry() {
System.out.println("赶紧结婚");
}
public void work() {
System.out.println("赶紧去挣钱");
}
}
7.object
object 是所有类的根基类 超类 父类
用法:
1.ctrl+0 罗列当前类中的所有方法
2.finaize: gc回收垃圾时 自动调用finaize
3.clone 克隆 :创建对象的一种方式 /深浅复制
4.hashode: 哈希码->哈希算法 唯一的值
5.getClass:获取当前类的class 对象 反射
6.equals:用来比较两个对象的内容是否相等 如果相等返回true否则返回false
object中的比较是通过==比较的
注意:
1.输出一个对象的时候,默认情况下会调用当前对象的totString
2.== 比较基本数据类型,比较的是值 比较引用类型比较的是地址
2.封装
含义:将抽象性函式接口的实现细节部份包装、隐藏起来的方法。封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。
public class Test01 {
public static void main(String[] args) {
// 创建一个Student
Student stu = new Student();
//stu.age = 100; //System.out.println("stu的年龄是:"+stu.age); stu.setGender(3);
System.out.println("stu的年龄是:"+stu.getGender());
}
}
class Student{
private int gender;
private int age;
public Student() {
}
public int getGender() {
return gender;
}
public void setGender(int gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age; }
}
class ArrayList{
private int size;// 实际存储容量
private int capacity;// 实际数组容量
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
}
3.修饰方法
修饰符作用:
1.用来屏蔽一些底层的实现逻辑,降低调用用者的复杂度
2.确保当前类更加安全
3.修饰符可以修饰类
4.属性(成员变量):
避免随意修改、获取属性,造成数据不安全
5.如果用private修饰的话,一定要保证对外提供get\set方法,让外部课件可以调用
public class FlowerUtil {
public static boolean isFlower(int num) {
//获取累加的和
int sum = sum(num);
return num==sum;
}
private static int sum(int num) {
//声明存放累加的结果
int result = 0;
// 声明一个方法 计算一个数字的长度 位数
int length = length(num);
while(num!=0) {
//分离每一位
int bit = num%10;
result = result+pow(bit,length);
num = num/10;
}
return result;
}
public static int pow(int bit,int length) {
int result = 1;
for(int i = 1;i<=length;i++) {
result = result*bit;
}
return result;
}
public static int length(int num) {
int length = 0;
while(num!=0) {
num = num/10;
length++;
}
return length;
}
}
c static int pow(int bit,int length) {
int result = 1;
for(int i = 1;i<=length;i++) {
result = result*bit;
}
return result;
}
public static int length(int num) {
int length = 0;
while(num!=0) {
num = num/10;
length++;
}
return length;
}
}