一.构造器
1.new创建对象做的三件事情:
1)在堆中为对象开辟空间,成员属性会跟随对象进入到堆内存并赋默认值
2)调用构造器为对象初始化信息
3)将地址返回值引用
2.构造器|构造方法|构造函数:
*构造器是一个特殊的方法,只能和new一起使用*
1)作用:
初始化对象信息,不是用来创建对象的
2)定义:
构造方法的名字必须与当前的类名一致 ,不需要返回值不需要void
修饰符 类名([参数列表]){
...
}
3)如果没有自定义构造器,编译器会自动为你添加空构造(不带参数的构造器)
4)如果存在自定义构造器,编译器这时不会再提供任何构造器,包括空构造
5)构造器是方法,方法就可以构成方法的重载
6)调用不同的构造器,看创建对象时候()中的参数列表匹配哪一个构造器的参数列表
7)修饰符可以是private,私有的,只能在本类中使用(单例)
8)构造器不能使用final,static,abstract修饰
总结:特殊的方法,只能通过new的使用使用,可以重载没有返回值和void,区分重载构造器看new后()的参数
public class ConstructorDemo {
//无参构造
public ConstructorDemo(){
System.out.println("我是一个无参构造器");
}
public static void main(String[] args) {
ConstructorDemo con=new ConstructorDemo();
//创建Dog对象
Dog dog=new Dog(); //创建对象时候的()-->构造器的形参
dog.name="uzi";
dog.color="白色";
dog.type="萨摩耶";
dog.lookHome();
//在创建对象的同时就可以指定或者初步确定这个对象的属性值,可以使用带参构造,在new对象的同时为对象的属性初始化值
Dog dog2=new Dog("花卷","二哈","黄色");
//dog2.color="粉色";
dog2.lookHome();
}
}
//小狗类
class Dog{
//名字
String name;
//品种
String type;
//颜色
String color;
//编译器会自动为你添加一个这个样子的空构造,没有参数,没有内容
public Dog(){
System.out.println("我是空构造");
}
//带参构造 构造器可以重载
public Dog(String n,String t,String c){
System.out.println("我是带3参构造");
name=n;
type=t;
color=c;
}
public Dog(String n,String t){
System.out.println("我是带2参构造");
name=n;
type=t;
}
public void lookHome(){
System.out.println("一个叫做"+name+"的"+color+"的狗在看家");
}
}
二.this.
1.指代当前new的对象,存储的就是当前对象的地址
1)在构造器的首行通过this调用当前其他构造器
this(); -->() 匹配构造器的参数
2)区分同名成员变量和局部变量
如果不使用this,会发生就近原则
在构造器中,this指代当前new的对象
在方法中,this指代当前调用成员方法的这个对象
如果不存在同名变量的问题,默认省略this.
如果存在同名变量的问题,默认就近原则,区分成员,this.,this.不能省略
2.注意:
1)在构造器的首行调用其他构造器时候不能相互调用
2)如果不使用,会发生就近原则
3)this不能使用在static修饰的方法中
3.构造块在编译的时候会被放在构造器语句块中代码的最上面,如果存在this调用其他构造器,必然先调用其他构造器,因为this必 须存在于首行才能调用其他构造器
public class ThisDemo {
public static void main(String[] args) {
Computer com=new Computer("apple",-15000,"银色");
System.out.println(com.brand);
System.out.println(com.price);
System.out.println(com.color);
com.price=-10000;
com.test("哈哈");
}
}
//电脑类
class Computer{
//品牌
String brand;
//价钱
double price;
//颜色
String color;
//空构造
public Computer() {
System.out.println("我是空构造器");
}
public Computer(String brand,double price) {
//this("",1.0,"");
System.out.println("我是带二个参数造器");
this.brand=brand;
if(price>=0){
this.price=price;
}else{
System.out.println("价钱<=0");
return;
}
}
public Computer(String brand,double price,String color) {
this(brand,price); //调用本类中的其他构造器
this.color=color;
System.out.println("我是带三个参数造器");
}
public void test(String brand){
String color="绿色";
System.out.println(this.brand+"->"+this.price+"->"+this.color);
}
}
三.static
1.static 关键字 静态的
static修饰变量|静态变量|类变量,只能修饰成员变量,不能修饰局部变量
static修饰方法|静态方法|类方法
static修饰的内容的使用方式:
1)类名.
2)对象.
2.注意:
静态的内容是属于类的,成员的内容是属于对象的
静态的内容是独一份的,这个类的所有对象共享这个类中的静态内容
在静态的内容中只能直接使用静态的内容,不能直接使用成员的内容===>对象使用
非静态的内容中,可以直接使用成员的内容,可以直接使用静态的内容
public class StaticDemo {
static int age;
int id;
public static void main(String[] args) {
//static int a=5;
System.out.println(age);
System.out.println(StaticDemo.age); //类名.
StaticDemo staticDemo=new StaticDemo();
System.out.println(staticDemo.age); //对象.
change();
System.out.println(age); // 1
System.out.println(staticDemo.id); // 0
//哪个调用的成员方法,在这个成员方法中,成员|this指代的都是调用成员方法的对象
staticDemo.test();
}
//静态方法 change
public static void change(){
age++;
StaticDemo staticDemo=new StaticDemo();
staticDemo.id++;
System.out.println(staticDemo.id);
}
public void test(){
age++;
id++; //哪个对象的成员
}
}
四.块block
1. {}自成作用域
{} ---->方法中,局部代码块|普通语句块 执行时机:调用方法
{} ---->类中方法外,构造块 执行时机:创建对象
static{} ---->静态块
2.构造块先于构造器执行,如果有多个构造块,从上到下一次执行
3.静态{}在第一次加载类的时候只执行一次,先于主方法执行,如果有多个静态块,从上到下一次执行
4.执行的顺序: 静态块 --- main ---构造块---构造器
public class BlockDemo {
static int a=5;
int b=3;
public BlockDemo() {
System.out.println("我是空构造");
}
//构造块
{
System.out.println("我是构造块1"+this.b);
a++;
b++;
}
{
System.out.println("我是构造块2");
}
{
System.out.println("我是构造块3");
}
//静态块
static{
a++;
BlockDemo bd=new BlockDemo();
bd.b++;
System.out.println("我是静态块");
}
static{
System.out.println("我是静态块2");
}
static{
System.out.println("我是静态块3");
}
public static void main(String[] args) {
System.out.println("main");
int a=9; //局部变量在外部无法使用,只能在当前方法中使用
{
a=7;
}
System.out.println(a); //
BlockDemo bd=new BlockDemo();
}
}
五.使用debug调试
1.步骤:
1)先打断点;(双击序号左边的蓝色区域)
2) debug模式运行(点击小虫子)
快捷键: f5 进入细节; f6下一步执行 ; f7返回方法的调用出;
六.gc
1. System.gc() 通知系统回收,但是无权决定是否回收,什么时候回收
2. finalize() 在垃圾回收机制来回收垃圾第一步会调用的方法
3. 一定会调用finalize()方法的两种情况:
1)匿名对象;
2)对象无引用状态;
public class GCDemo {
public static void main(String[] args) {
//匿名对象 只能在当前行用一次
new GCDemo().test(); //没有名字的对象
//System.gc();
//对象无引用状态
GCDemo d=new GCDemo();
d.test();
GCDemo d1=d;
d=null;
System.gc();
}
@Override
protected void finalize() throws Throwable {
System.out.println("over...");
}
public void test(){
System.out.println("hhhhhhhhhh");
}
}
七.package 和 import
1.注意: 不要定义与 jdk 相同的包,相同的类,否则会引起很多你觉得莫名其妙的问题;
2.导包: 模糊匹配 *
3.会拖慢编译效率,不会拖慢运行速度
4.静态导入:单独导入类中的静态的内容
可以导入变量可以导入方式
八.private
1.私有的,成员修饰符,不能修饰局部变量
2.私有的内容只能在当前类中使用
3.如何使用私有的属性:
对使用的属性提供公共的访问方式 setter设置器 getter访问器
九.面向对象的三大特征之一: 封装
1.封装:对外隐藏内部的实现细节,提供公共的访问方式就是封装
属性私有,公共的访问方式是封装的一个具体的体现(不能说封装是私有)
类,方法都是封装的体现
2.以后写模板类,属性都要私有,提供公共的访问方式
3.这种模板类|实体类|javabean
1)类是公共的public修饰
2)至少存在一个空构造
3)属性私有
4)公共的访问方式
public class Person {
//姓名
String name;
//年龄
private int age;
//设置器 setter 给私有的age属性的设置值
//返回值:不需要 参数:int参数
public void setAge(int age){
if(age>0){
this.age=age;
}else{
//如果参数不满足条件,默认1岁
this.age=1;
}
}
//学习
public void study(){
System.out.println(name+age+"早睡早起...");
}
}
九.面向对象的三大特征之一: 继承
1.抽取对象的共性定义为类;
抽取类的共性定义为父类;
2.为什么使用继承:
为了提高代码的复用性
如何使用继承(子承父业:拓展+延续):
格式: 子类 extends 父类 ====>子类继承父类 ,例如 class Cat extends Animal{ }
3.使用继承的优点:
1)提高代码的复用性
2)自动可以使用父类中的所有成员(属性和方法)
3)子类可以定义属于自己的属性和功能 ---->扩展
4.特点:
父类可以有多个子类,但是一个子类只能有一个父类 ---->单继承
5.单继承的优点: 使用简单
单继承的缺点: 不便于后期维护
6. 其它叫法: 父类|基类|超类
子类|派生类
public class ExtendsDemo {
public static void main(String[] args) {
Dog dog=new Dog();
dog.name="小坤蔡";
dog.type="柴犬";
dog.color="土黄色";
dog.shout();
}
}
//父类
class Animal{
String name;
String type;
String color;
public void shout(){
System.out.println(name+"叫叫叫!!!!");
}
}
//小狗
class Dog extends Animal{
public void lookDoor(){
System.out.println(name+"看家!!!!");
}
}
//小猫
class Cat extends Animal{
//新增方法
public void catchMouse(){
System.out.println(name+"捉老鼠!!!!");
}
}