认识类

类名注意采用大驼峰定义成员前写法统一为 public.此处写的方法不带 static 关键字.
public class Dog { //定义类//类的成员属性public String name;//名字public int age;//年龄public String color;//颜色//类的成员方法//吃饭public void eat(){System.out.println("摇尾巴");}//叫声public void bark(){System.out.println("汪汪汪");}
}
1. 一般一个文件当中只定义 一个类2. main方法所在的类一般要使用public修饰(注意:Eclipse默认会在public修饰的类中找main方法)3. public修饰的类必须要和文件名相同
类的实例化

objectName
是为新创建的对象指定的变量名 new 关键字用于创建一个对象的实例.使用 “ . ”来访问对象中的属性和方法.对象名.类的成员名
同一个类可以创建多个实例
类和对象的说明
public static void main(String[] args){//类的实例化2Dog dog=new Dog();dog.name="大黄";dog.age=3;dog.color="yellow";dog.eat();//类的实例化3Dog dog2=new Dog();dog2.name="黑虎";dog2.age=5;dog2.color="black";dog2.bark();}
this引用



1. this的类型:对应类类型引用,即哪个对象调用就是哪个对象的引用类型2. this只能在"成员方法"中使用3. 在"成员方法"中,this只能引用当前对象,不能再引用其他对象4. this是“成员方法”第一个隐藏的参数,编译器会自动传递,在成员方法执行时,编译器会负责将调用成员方法对象的引用传递给该成员方法,this负责来接收。

对象的构造及初始化
构造方法
完成一个对象的构造,分两步:1.分配内存2.调用合适的构造方法
名字必须与类名相同没有返回值类型,设置为void也不行一般情况下使用public修饰在创建对象时,由编译器自动调用,并且在整个对象的生命周期内只调用 一次构造方法之间可以构成方法重载(用户根据自己的需求提供不同参数的构造方法)
public class Dog { //定义类//类的成员属性public String name;//名字public int age;//年龄public String color;//颜色//无参构造方法public Dog(){// 1// 无参构造方法--内部给各个成员赋值初始值,该部分功能与三个参数的构造方法重复// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法// 但是this("小灰",6,"yellow");必须是构造方法中第一条语句this("小灰",6,"yellow");// //2// this.name="小灰";// this.age=6;// this.color="yellow";}//带三个参数的构造方法public Dog(String name,int age,String color){this.name=name;this.age=age;this.color=color;}//打印public void Print(){System.out.println("name:"+this.name+" age:"+this.age+" color:"+this.color);}public static void main(String[] args){//此次创建一个Dog类型的对象,并没有显示调用构造方法Dog dog5=new Dog();//Dog()构造方法被调用dog5.Print();Dog dog6=new Dog("小白",9,"black");//Dog(String,int,String)构造方法被调用dog6.Print();}
}
this();调用当前类的其他构造方法,只能在当前的构造方法内部第一行使用
this.field 访问当前对象的属性
this.method() 调用当前对象的方法
//errpublic Dog() {this("小灰",6,"yellow");}public Dog(String name,int age,String color){this();}//无参构造器调用三个参数的构造器,而三个参数构造器有调用无参的构造器,形成构造器的递归调用//编译报错:java: 递归构造器调用
默认初始化
public static void main(String[] args){int a;System.out.println(a);
}//error java: 可能尚未初始化变量a
但我们发现成员变量未初始化仍然可以编译成功,这是为什么?
public static void main(String[] args){Dog dog4=new Dog();System.out.println("name:"+dog4.name+" age:"+dog4.age+" color:"+dog4.color);
}
当成员变量未初始化时:
引用类型一般默认为null
基本类型一般为自己的0值
一个类中无构造方法,java会自动提供一个不带参数的构造方法
只要有一个构造方法,java不提供任何构造方法
我们发现当我们删去无参构造方法时,因为有带三个参数构造方法的存在,编译器不提供任何构造方法,因此在main方法中调用Dog()时出现错误
Classname objectname = new ClassName() ;
数据类型 | 默认值 |
---|---|
byte | 0 |
char | '\u0000' |
short | 0 |
int | 0 |
long | 0L |
boolean | false |
float | 0.0f |
double | 0.0 |
reference | null |
就地初始化
封装
private


public class Dog {private String name;//名字private int age;//年龄public String color;//颜色//获取name成员public String getName() {return name;}//修改name成员public void setName(String name) {this.name = name;}//获取age成员public int getAge() {return age;}//修改age成员public void setAge(int age) {this.age = age;}
}class test{public static void main(String[] args) {Dog dog=new Dog();dog.setName("大黄");//调用setName方法,修改name成员System.out.println(dog.getName());//调用getName方法,获取name成员dog.setAge(8);//调用setAge方法,修改age成员System.out.println(dog.getAge());//调用setAge方法,获取age成员}
}
访问限定符
Java中主要通过类和访问权限来实现封装:1. 类可以将数据以及封装数据的方法结合在一起2. 访问权限用来控制方法或者字段能否直接在类外使用
范围/访问限定符 | private | default | protected | public |
同一包中的同一类 | 是 | 是 | 是 | 是 |
同一包中的不同类 | 是 | 是 | 是 | |
不同包中的子类 | 是 | 是 | ||
不同包中的非子类 | 是 |
protected主要是用在继承中default权限指:什么都不写时的默认权限访问权限除了可以限定类中成员的可见性,也可以控制类的可见性
封装扩展之包
包的概念
常见包
导入包中的类

2. 使用 import语句导入包.
3. 如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

import static java.lang.Math.*;//导入java.lang.Math中的所有类
public class Test {public static void main(String[] args) {double x=3;double y=4;double a=Math.sqrt(Math.pow(x,2)+Math.pow(y,2)); //a=5double b=sqrt(pow(x,2)+pow(y,2));//静态导入 //b=5System.out.println(a);System.out.println(b);
}
自定义包
1. 在文件的最上方加上一个 package 语句指定该代码在哪个包中.2. 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).3. 包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.4. 如果一个类没有 package 语句, 则该类被放到一个默认包中.

包的访问权限控制举例
package com.bit.demo1;public class Dog {private String name;//名字private int age;//年龄public String color;//颜色String sex;//default属性public Dog(String name,int age,String color,String sex){this.name=name;this.age=age;this.color=color;this.sex=sex;}//吃饭private void eat(){System.out.println("摇尾巴");}//叫声public void bark(){System.out.println("汪汪汪");}//睡觉void sep(){System.out.println("睡觉");}public static void main(String[] args) {Dog dog=new Dog("大黄",3,"yellow","男");System.out.println(dog.name);System.out.println(dog.age);System.out.println(dog.color);System.out.println(dog.sex);dog.eat();dog.bark();dog.sep();}
}
package com.bit.demo1;public class TestDog {public static void main(String[] args) {Dog dog=new Dog("大黄",3,"yellow","男");System.out.println(dog.color);// System.out.println(dog.name);//err name是私有的,不允许被其他类访问System.out.println(dog.sex);// sex是default,允许被同一包中的不同类访问dog.bark();// dog.eat();//errdog.sep();}
}
package com.bit.demo2;
import com.bit.demo1.Dog;
public class TestDog {public static void main(String[] args) {Dog dog=new Dog("大黄",3,"yellow","男");System.out.println(dog.color);// System.out.println(dog.name);//err name是私有的,不允许被其他类访问// System.out.println(dog.sex);//err sex是default,不允许被其他包中的类访问dog.bark();// dog.eat();//err// dog.sep();//err}
}
static 成员
public class Dog {//非静态成员变量public String name;//名字public int age;//年龄public String color;//颜色//静态成员变量(类成员)private static String species;public Dog(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}public void print(){System.out.println("name:"+this.name+" age:"+this.age+" color:"+this.color+" species:"+Dog.species);}public static void main(String[] args) {Dog.species="中华田园犬";Dog dog1 = new Dog("大黄",1,"yellow");dog1.print();Dog dog2 = new Dog("小灰",2,"black");dog2.print();Dog dog3= new Dog("小白",3,"brown");dog3.print();}
}
public class Dog {//非静态成员变量public String name;//名字public int age;//年龄public String color;//颜色//静态成员变量(类成员)private static String species;//非静态成员方法public void eat(){System.out.println("摇尾巴");}//静态成员方法(类成员)public static void sleep(){System.out.println("睡觉");//age=10;//err 无法从静态上下文中引用非静态 变量 age//eat();//err 无法从静态上下文中引用非静态方法 eat()Dog dog=new Dog();System.out.println(dog.name="小花");dog.eat();}public static void main(String[] args) {//通过对象访问Dog dog0=new Dog();System.out.println(dog0.species="中华田园犬");dog0.sleep();//通过类名访问System.out.println(Dog.species="猎犬");Dog.sleep();}
}
代码块
代码块概念以及分类
{}
包围的一段代码,它定义了一组可以一起执行的语句。这种代码块可以出现在方法体内部,也可以作为 if
、 else
、 for
、 while
、 do-while
等控制流语句的一部分。 静态代码块不管生成多少个对象,其 只会执行一次静态成员变量是类的属性,因此是在JVM加载类时开辟空间并初始化的如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行(合并)静态代码块只要类被加载,就会被执行
public class Dog {//非静态成员变量public String name;//名字public int age;//年龄public String color;//颜色//静态成员变量(类成员)private static String species;//构造代码块(实例代码块){this.name="小黑";this.age=2;this.color="yellow";System.out.println("这是实例代码块");}//静态代码块static {species="牧羊犬";System.out.println("这是静态代码块");}static {species="运动犬";System.out.println("这是静态代码块2");}//构造方法public Dog() {this.name = name;this.age = age;this.color = color;System.out.println("这是构造方法");}public void print(){System.out.println("name:"+this.name+" age:"+this.age+" color:"+this.color+" species:"+Dog.species);}public static void main(String[] args) {Dog dog1 = new Dog();dog1.print();Dog dog2 = new Dog();dog2.print();
}
根据编译结果我们可以得到
运行时执行顺序为:静态代码块 实例代码块 构造方法
静态代码块只执行一次
public static void main(String[] args) {System.out.println(Dog.species);
}
当我们只加载类时,静态代码块就会被执行,而实例代码块只有在创建对象时才会执行