定义类:
定义类的语法如:
[修饰符] class 类名{
零到多个构造器定义...
零到多个Field(成员变量)...
零到多个方法...
}
修饰符:public,final,abstract或者省略修饰符;
在类中,static修饰过成员不能访问没有static修饰成成员;
定义成员变量语法格式:
[修饰符] Field类型 Field名 [= 默认值];
修饰符可以省略,也可以是
public,protected,private,static,final(同色表示只能出现一个)
定义方法的语法格式:
[修饰符] 方法返回值类型 方法名(形参列表){
//方法体
}
修饰符可以省略,可以是
public,protected,private,static,
final,abstract
static
static是一个特殊的关键字,可用于修饰成员变量,成员方法;
static修饰的成员表明它属于这个类本身,而不属于该类的单个实例对象,故static修饰的成员变量,成员方法也成为类Field,类方法;不实用static修饰的叫实例对象,实例方法;
静态成员不能直接访问非静态成员;
final关键字
final关键字可以用来修饰类,变量和方法;
final修饰变量表示该变量获得了初始值久不可被改变;既可以修饰成员变量,也可以修饰局部变量,形参;
final修饰的方法不可被重写;
final类不可以有子类;
final修饰的成员变量必须有程序员显示地指定初始值;
方法的参数传递机制
Java里方法的参数传递方式只有一种:值传递。即将实际参数值的副本传入方法内,而参数本身不会受到任何影响。
基本类型的参数传递:
public class test{
public static void swap(int a,int b){
int tmp = a;
a = b;
b = tmp;
System.out.println("swap方法里,a的值是:"+a+",b的值是:"+b);
}
public static void main(String[] args){
int a = 6;
int b = 9;
swap(a,b);
System.out.println("交换结束后,a的值是:" + a + ",b的值是:" + b);
}
}
输出结果:
swap方法里,a的值是:9,b的值是:6
交换结束后,a的值是:6,b的值是:9
引用类型的参数传递:
class D{
public int a;
public int b;
}
public class test{
public static void swap(D x){
int tmp = x.a;
x.a = x.b;
x.b = tmp;
System.out.println("swap中,a的值是:"+x.a+";b的值是:"+x.b);
}
public static void main(String[] args){
D d = new D();
d.a = 6;
d.b = 9;
swap(d);
System.out.println("交换结束后,a的值是:"+d.a+";b的值是:"+d.b);
}
}
输出结果:
swap中,a的值是:9;b的值是:6
swap中,a的值是:9;b的值是:6
引用类型中,传递的也是值传递,由于是引用变量,传递的是地址,swap和main中操作的是指向同一地址的对象;
成员变量和局部变量
成员变量:在类范围里定义的变量,即Field;
1.实例成员变量:从该类的实例被创建开始存在,直到系统完全销毁这个实例;
2.类成员变量(加static):从类的准备阶段就开始存在,知道系统完全销毁这个类,与这个类的生存范围一样。
一个类的实例修改类成员变量之后,其它实例访问类成员变量的值是修改之后的值;
class Person
{
public String name;
public static int num;
}
public class test
{
public static void main(String[] args)
{
System.out.println("Person的成员变量num:"+Person.num);
Person p = new Person();
System.out.println("实例成员变量name:"+p.name+";num:"+p.num);
p.name = "Dark";
p.num = 2;
System.out.println("p的成员变量name:"+p.name+";num:"+p.num);
System.out.println("Person的成员变量num:"+Person.num);
Person m = new Person();
System.out.println("m的成员变量name:"+m.name+";num:"+m.num);
}
}
输出结果:
Person的成员变量num:0
实例成员变量name:null;num:0
p的成员变量name:Dark;num:2
Person的成员变量num:2
m的成员变量name:null;num:2
局部变量:在方法里定义的变量;
局部变量根据定义形式 的不同,可以分为:
1.形参:在定义方法签名时定义的变量,形参的作用域在整个方法类有效;
2.方法局部变量:在方法体内定义的局部变量,它的作用域从定义该变量的地方生效,到该方法结束时失效;
3.代码块局部变量:在代码块中定义的局部变量;
局部变量除了形参外,都必须显示初始化,指定初始值,否则不可以访问;
public class test
{
private String name = "Dark";
private static double price = 78.0;
public static void main(String[] args)
{
int price = 65;
System.out.println(price);
System.out.println(test.price);
new test().info();
}
public void info(){
String name = "White";
System.out.println(name);
System.out.println(this.name);
}
}
输出结果:
65
78.0
White
Dark
封装
封装指的是将对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部信息,而是通过该类所提供的方法来实现对内部信息的操作和访问。
Java提供3个访问控制符:public,private,protected,还有一个不加任何访问控制符的访问控制级别default;
当不适用任何访问控制符来修饰类或类成员时,默认为default;
访问控制级别由小到大;
private<default<protected<public
private(当前类访问权限):如果类里的一个成员使用private,该成员只能在当前类的内部被访问,最适合用来修饰Field;
default(包访问权限):如果类里的一个成员或者一个外部类不使用任何访问控制修饰符,即包访问权限,default访问控制的成员或外部类可以被相同包下的其他类访问;
protected(子类访问权限):若成员适用protected访问控制修饰符,该成员既可以被同一个包中的其他类访问,也可以被不同包中的子类访问;
public(公共访问权限):若一个成员或外部类使用public访问控制修饰符,该成员或外部类就可以被所有的类访问,不论访问类和被访问类是不是处于同一个包,是否有继承关系;
封装实例:
class Person{
private String name;
private int age;
public void setName(String name){
if(name.length() > 6 || name.length() < 2)
{
System.out.println("您设置的人名不符合要求");
return;
}
else
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
if(age > 100 || age < 0)
{
System.out.println("您设置的年龄不合法");
return;
}
else
this.age = age;
}
public int getAge()
{
return this.age;
}
}
public class test{
public static void main(String[] args)
{
Person p = new Person();
p.setAge(1000);
System.out.println(p.getAge());
p.setAge(30);
System.out.println(p.getAge());
p.setName("Dark");
System.out.println(p.getName());
}
}
继承
修饰符 class SubClass extends SuperClass{
//类定义部分
}
重写父类方法:
——要方法名,形参列表相同;
若要调用被覆盖的方法,如果是实例方法是用super,类方法可以用父类类名;
class BaseClass
{
public int a = 5;
}
public class SubClass extends BaseClass
{
public int a = 7;
public void toOwner()
{
System.out.println(a);
}
public void toBase()
{
System.out.println(super.a);
}
public static void main(String[] args)
{
SubClass m = new SubClass();
m.toOwner();
m.toBase();
}
}
输出结果:
7
5
继承时构造器之间的调用关系
class Creature{
public Creature(){
System.out.println("Creature无参数的构造器");
}
}
class Animal extends Creature{
public Animal(String name){
System.out.println("Animal带一个参数的构造器,该动物的name为:"+name);
}
public Animal(String name,int age){
this(name);//使用this调用同一个重载的构造器
System.out.println("Animal带两个参数的构造器,其age为:"+age);
}
}
public class Wolf extends Animal{
public Wolf(){
super("灰太狼",3);
System.out.println("Wolf无参数的构造器");
}
public static void main(String[] args){
new Wolf();
}
}
result:
Creature无参数的构造器
Animal带一个参数的构造器,该动物的name为:灰太狼
Animal带两个参数的构造器,其age为:3
Wolf无参数的构造器
多态
父类声明,子类实现;即:
BaseClass test = new SubClass();
当把一个子类对象直接赋给父类的引用变量时,当运行时调用该引用变量的方法时,其方法行为总时表现出子类方法的行为特征,而不是父类方法的行为特征;
对象的Field不具备多态性;
包装类
Java为8个基本类型提供了对应的包装类,通过这些包装类可以把8个基本类型的值包装成对象使用;
int为Integer,char为Character,其他只是改变为首字母大写;
public static void main(String[] args) {
boolean b = true;
Boolean bObj = new Boolean(b);
int i = 5;
Integer IntObj = new Integer(i);
Float f = new Float("4.56"); //把字符串转换成Float对象
Boolean bbObj = new Boolean("false");
}
包装类实现基本类型变量和字符串之间的转换:
抽象
抽象方法和抽象类必须使用abstract修饰符来定义,有抽象方法的类只能被定义成抽象类,抽象类可以没有抽象方法;
规则:
1.抽象方法不能有方法体;
2.抽象类不能被实例化;
3.抽象类可包含Field,方法,构造器,主要用于被子类调用;
接口
接口是一种特殊的抽象类,接口里不能包含普通方法,其中所有的方法都是抽象方法;
接口的定义:
[修饰符] interface 接口名 extends 父接口1,父接口2...
{
零到多个常量定义...
零到多个抽象方法定义...
}
使用接口:
[修饰符] class 类名 implements 接口1,接口2...
{
类体部分...
}
内部类
。。。。
引用类型数组的初始化
class Person{
public int age;
public double height;
public void info(){
System.out.println("My age is:" + age +",My heght is:" + height);
}
}
public class test{
public static void main(String[] args){
Person[] students = new Person[2];
Person zhang = new Person();
zhang.age = 15;
zhang.height = 158;
Person lee = new Person();
lee.age = 16;
lee.height = 161;
students[0] = zhang;
students[1] = lee;
lee.info();
students[1].info();
}
}