类和对象的定义格式：
/** 面向过程：以步骤为单位，一步一步完成某一个具体事情 面向对象：以对象为单位，通过调度组合不同的对象来完成某一个事情 */ public class Test1{ public static void main(String[] args){ //int i = 0; Horse h = null; //声明一个类的变量(除了八种基本数据类型以外，都是引用数据类型，包括数组) //创建一个Horse类型的对象，实例对象 h = new Horse(); //有了对象，我们就可以调用对象的属性和方法 h.name = "赤兔马"; h.age = 350; h.run();//调用方法，那么方法就会被执行。 h.eat(); //匿名对象:只能使用一次，用完后，该对象就会被释放 new Horse().eat(); h = null;//把对象释放 //h.eat();//当对象不存在时，调用该对象的属性和方法将报错（空指针） //-------------------- Horse h1 = null; Horse h2 = null; h1 = new Horse(); //h2 = new Horse(); h1.name = "小白"; h1.age = 4; //h2.name="小黑"; //h2.age=5; h2 = h1;//对象之间的赋值,相同类型才可以赋值 h2.name="小黑"; System.out.println(h1.name); System.out.println("----------------------"); Horse h3 = null; Horse h4 = null; h3 = new Horse(); h4 = new Horse(); h3.name = "小白"; h3.age = 4; h4.name="小黑"; h4 = h3; h4.name = "嘿嘿"; System.out.println(h3.name); } } //自定一个类（类型） class Horse{ //在类中定义属性（特征） String name;//字符串是引用类型变量，不是基本数据类型变量 int age; public void run(){ System.out.println("我是"+name+",我"+age+"岁了,我还日行千里"); } public void eat(){ System.out.println("我吃仙草，还吃得多"); } }
对象和类的内存分析：
内存的封装性：
/** 封装性 如果属性没有封装，那么在本类之外创建对象后，可以直接访问属性 private关键字：访问权限修饰符，public表示公有的，private表示私有的,私有的属性或方法，只能在本类中访问， 公有的属性和方法，可以被类外部的其它类访问,想要在类外部访问私有属性，我们需要提供公有的方法来间接访问, 通常在一个类中，属性都私有化，并对外提供getter and getter方法 */ public class Test2{ public static void main(String[] args){ Person p1 = new Person(); //p1.name = "菲菲"; //p1.age = 18; p1.setName("菲菲"); p1.setAge(18); p1.run(10); p1 = null; } } //没有封装之前 class Person{ //属性的封装 private String name; //成员变量，在类中定义 private int age; //成员变量，在类中定义 //getter and setter //对外提供一个为name属性设值的方法 public void setName(String name){ this.name = name; } //对外提供一个获取name属性的方法 public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } public void run(int len){//参数也是局部变量 int i; int m = len; // m也是局部变量 System.out.println("我跑了"+m+"米"); System.out.println(age); } }
/**
构造方法:构造方法是在类中定义的，构造方法的定义格式：方法名称与类名称相同，无返回值类型的声明。
1、构造方法就是类构造对象时调用的方法，用于对象的初始化工作
2、构造方法是实例化一个类的对象时，也就是new 的时候，最先调用的方法。
*/
public class Test3{
public static void main(String[] args){
//Dog dog = new Dog();
Dog dog1 = new Dog("wangwang",5);
}
}
class Dog{
//构造方法:构造方法是在类中定义的，构造方法的定义格式：方法名称与类名称相同，无返回值类型的声明。
//默认构造方法,通常有其它构造方法时，要保留默认构造方法
public Dog(){
System.out.println("默认的构造方法，执行了");
}
//带参数的构造方法:
public Dog(String name){
this.name = name;
System.out.println("带一个参数的构造方法执行了");
//注意：如果类中有带参数的构造方法，那么默认的构造方法将不起作用
}
public Dog(String name,int age){
this(name);//调用其它构造方法时，此语句必须在第一句否则报错,在构造方法相互调用时必须要有出口,这就是调用显示println("带一个参数的构造方法执行了")
//this.name = name;
this.age = age;
System.out.println("带两个参数的构造方法执行了");
}
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
this关键字：
表示当前对象:在方法被调用的过程中，哪个对象调用了方法，在方法内的this就表示谁
/** this关键字 调用类中的属性 · 调用类中的方法或构造方法 · 表示当前对象:在方法被调用的过程中，哪个对象调用了方法，在方法内的this就表示谁 类名.this */ public class Test4{ public static void main(String[] args){ Cat cat = new Cat(); cat.setName("咪咪"); cat.setAge(3); cat.eat(); } } class Cat{ private String name; private int age; public void setName(String name){ //name=咪咪 this.name = name; //this代表的是当前对象 } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } public void eat(){ //在方法中使用this调用类中的其它方法或属性，this可以省略,this前面可以使用当前的类名.this //在后面的内部类知识点中会涉及到 System.out.println("我是"+Cat.this.getName()+",我爱吃鱼"); //System.out.println("我是"+this.name+",我爱吃鱼"); } }
值传递与引用传递
1 //示例二：引用传递 2 public class RefDemo1{ 3 public static void main(String[] args){ 4 Duck d = new Duck(); 5 method(d) ; 6 System.out.println("Duck age = "+d.age); 7 } 8 public static void method(Duck duck){ 9 duck.age = 5; 10 } 11 } 12 class Duck{ 13 int age = 2; //省略封装 14 }
//示例三：String传递 //字符串本身就是一个对象 public class RefDemo2{ public static void main(String[] args){ String name = "小飞"; method(name) ; System.out.println("name="+name) ; } public static void method(String sname){ sname = "小备"; } }
//示例四：String传递 public class RefDemo3{ public static void main(String[] args){ Person p = new Person(); method(p) ; System.out.println("person name= "+p.name) ; } public static void method(Person per){ per.name = "备备"; } } class Person{ String name = "飞飞"; //省略封装 }
对象的一对一关系：
/** 两个对象之间的一对一关系： 比如：一个英雄（Hero）对一个兵器（Weapon） 双向一对一 单向一对一 */ public class Test5{ public static void main(String[] args){ Hero hero = new Hero("刘备",300); Weapon weapon = new Weapon("双股剑",3); //把两个对象关联起来 hero.setWeapon(weapon); weapon.setHero(hero); //通过英雄来获取他的信息 String name = hero.getName(); int age = hero.getAge(); Weapon w = hero.getWeapon(); System.out.println("我是"+name+"，我"+age+"岁，我的武器是："+w.getName()+",排行"+w.getGrade()+"级"); } } //英雄类 class Hero{ private String name; private int age; private Weapon weapon;//一对一关系 public void setWeapon(Weapon weapon){ this.weapon = weapon; } public Weapon getWeapon(){ return weapon; } public Hero(){} public Hero(String name,int age){ this.name = name; this.age = age; } public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } } //兵器类 class Weapon{ private String name; private int grade; private Hero hero; public void setHero(Hero hero){ this.hero = hero; } public Hero getHero(){ return hero; } public Weapon(){} public Weapon(String name,int grade){ this.name = name; this.grade = grade; } public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setGrade(int grade){ this.grade = grade; } public int getGrade(){ return grade; } }
/** static 关键字 1、静态变量或方法不属于对象，依赖类 2、静态变量是全局变量，生命周期从类被加载后一直到程序结束 3、静态变量只有存一份，在静态方法区中存储 4、静态变量是本类所有对象共享一份 5、建议不要使用对象名去调用静态数据，直接使用类名调用 6、static修饰一个方法，那么该方法属于类，不属于对象，直接用类名调用 7、静态方法不能访问非静态属性和方法，只能访问静态。 */ public class Test6{ public static void main(String[] args){ System.out.println(args.length); for(String s: args){ System.out.println(s); } //Role beibei = new Role("刘备","蜀国"); //Role yunchang = new Role("云长","蜀国"); //Role feifei = new Role("张飞","蜀国"); Role beibei = new Role("刘备"); Role yunchang = new Role("云长"); Role feifei = new Role("张飞"); System.out.println(beibei.getInfo()); System.out.println(yunchang.getInfo()); System.out.println(feifei.getInfo()); System.out.println(beibei.country); System.out.println(yunchang.country); System.out.println(feifei.country); beibei.country = "秦国"; System.out.println("------------------"); System.out.println(beibei.country); System.out.println(yunchang.country); System.out.println(feifei.country); System.out.println("------------------"); System.out.println(Role.country);//用类名调用静态变量 } } //角色 class Role{ private String name; static String country = "蜀国";//静态变量（全局变量） public Role(String name,String country){ this.name = name; this.country = country; } public Role(String name){ this.name = name; } public void setName(String name){ this.name = name; } public String getName(){ return name; } //静态方法不能访问非静态的数据 public static void setCountry(String country){ Role.country = country; } /* public void setCountry(String country){ this.country = country; } public String getCountry(){ return country; } */ public String getInfo(){ return "name="+name+",country="+country; } }
代码块：
/** 代码块： 1、普通代码块，在方法中写的代码块 2、构造块，是在类中定义的代码块，在创建对象时被调用，优于构造方法执行 3、在类中使用static声明的代码块称为静态代码块 在第一次使用的时候被调用（创建对象），只会执行一次，优于构造块执行 我们在项目开发中，通常会使用静态代码块来初始化只调用一次的数据。比如说： 小结：重点会使用的顺序是静态代码块，普通代码块，同步代码块，构造代码块 */ public class Test7{ public static void main(String[] args){ //Student s = new Student(); //Student s1 = new Student(); //Student s = null; } } class Student{ static{ System.out.println("我是静态代码块"); } public Student(){ System.out.println("构造方法"); } { System.out.println("我是构造代码块"); } public void study(){ //限制作用域 { int i = 10; System.out.println("我是普通代码块"); } } }
单例模式：
