目录
对象与引用
值传递与引用传递
值传递
引用传递
this关键字
static关键字
修饰成员变量
修饰成员方法
代码块
实例代码块
静态代码块
调用
类的加载与执行
包
概念
作用
命名规范
访问权限修饰符
public
protected
默认
private
面向对象特征
三大特征
封装
对象与引用
1.Java中,除基本类型外的变量类型都称之为引用类型;
2.Java中的对象是通过引用对其操作的;
3.以Car bm = new Car();为例:是以Car类为模板,在堆空间里创建一个Car类对象;左边的Car bm创建了一个Car类型的引用变量(以后可以用来指向Car对象的对象引用)“=”操作符使对象引用指向刚创建的那个Car对象;Car bm;bm=new Car;拆成两部分理解,一是对象引用变量,一是对象本身;
解释说明:
值传递与引用传递
值传递
值传递:基本类型作为参数;
public class TestValue { public void test(int x){ x = 20;//变量x值发生变化,与a没有任何关系 } public static void main(String[] args) { TestValue t = new TestValue(); int a = 10; t.test(a);//传递的是基本类型,可是用a的值实际填充了x, 是两个不相干的变量 System.out.println(a);//10 } }
引用传递
引用传递:本质上也是值传递,只是为了和基本类型区分,称为引用地址传递;
public class TestRef { public void test(Person p){//p = p1 = (地址) 指向的是同一个对象 p.name = "李四"; } public static void main(String[] args) { TestRef t = new TestRef(); Person p1 = new Person(); //p1=(地址) p1.name = "张三"; p1.age = 20; t.test(p1);//对于引用类型,只是将对象的引用地址值传递 System.out.println(p1.name);//李四 } }
this关键字
1.this关键字代表当前对象;
2.使用this关键字引用成员变量;
3.使用this关键字引用成员方法;
static关键字
1.static 静态,修饰类的属性,方法,代码块,内部类;
2.随着类的加载而加载;
3.优先于对象存在;
4.修饰的成员,被所有对象所共享;
5.可不创建对象,直接被类调用;
作用:优化内存空间;
修饰成员变量
被static修饰的成员变量,成员方法可以被类调用,属于类,只有一个;
public class Chinese { String name ;//姓名 每个人姓名都不一样, 没创建一个对象,对象中就会有一个name属性 //所有对象都一样的成员变量,可以修饰为static,称为类变量,随着类的加载而加载 static String country="中国";//国家, 每个对象中也都有一个country,就是一个静态变量(类变量) }
修饰成员方法
public class Chinese { String name ;//姓名 每个人姓名都不一样, 没创建一个对象,对象中就会有一个name属性 //所有对象都一样的成员变量,可以修饰为static,称为类变量,随着类的加载而加载 static String country="中国";//国家, 每个对象中也都有一个country,就是一个静态变量(类变量) public static void showCountry(){ System.out.println("国籍:"+country); } public void showInfo(){ System.out.println("姓名"+name+"国籍"+country); } }
public class TestChinese { public static void main(String[] args) { // Chinese.name; name是非静态的成员变量,属于对象,类不能直接访问, //country被static修饰了,所有属于类,内存中只有一份,随着类加载而被加载初始化,建议使用类名访问静态 System.out.println(Chinese.country); Chinese c1 = new Chinese(); System.out.println(c1.country); //c1.country= "中国人"; Chinese.country = "中国人"; Chinese c2 = new Chinese(); System.out.println(c2.country); c2.name = "jim"; c2.showInfo(); //Chinese c3 = new Chinese(); // c3.showCountry(); Chinese.showCountry(); } }
静态的不能访问非静态的,非静态的可以访问非静态的;
代码块
代码块分为两种,在类中定义的代码块,没有名字;
实例代码块
没有被static修饰的代码块,在创建对象时会自动调用;
静态代码块
在类被加载时只调用一次;(默认认为一个类只被加载一次,一旦第一次加载后,就永远存在)
调用
满足条件后,自动调用;
public class Demo { { System.out.println("实例代码块1"); } { System.out.println("实例代码块2"); } static{ System.out.println("静态代码块1"); } static{ System.out.println("静态代码块2"); } public Demo(){ System.out.println("无参构造"); //实例代码块先于构造方法执行; } public static void test(){ } public static void main(String[] args) { //若把main方法写在Demo类里,静态代码块也会执行,因为Demo类被加载了; } }
注:实例代码块先于构造方法执行;
若把main方法写在Demo类里,静态代码块也会执行,因为Demo类被加载了;
public class TextDemo { public static void main(String[] args) { //类只被加载一次,问:什么时候会发生加载动作;创建对象的时候;调用类中的静态成员; // Demo.test();//静态代码块执行,未创建对象,实例代码块不执行; new Demo();//创建Demo类对象,先加载Demo类(加载静态成员),静态的先执行 // new Demo();//静态代码块执行一次,实例代码块执行两次; } }
类的加载与执行
类只被加载一次,什么时候会发生加载动作:创建对象的时候;调用类中的静态成员;
包
概念
为了更好的组织包装,Java提供了包机制,用于区别类名的命名空间,可以理解为一个文件夹;
类名 Car(简称)
类名==全类名==包名(类的地址)+类名;
作用
区分重名的类;
按照不同功能管理类;
控制访问权限;
命名规范
包名一般情况是小写,用“ . ”来区分包的等级;
第一级指该项目的类型,如com,org(开源组织),gov(政府)等;
第二级指项目所开发或者运行的公司名称,如: oracle,sun,huawei等;
第三级指项目的名称,如:bcms,oa,erp,cms等第四级指项目模块的名称,如:bean,action,exception等。
包可以更好得管逻辑相关的类,可以控制不同包之间的访问权限;
导入外部包的类,关键字“import";
package com.wm.javaoop.test; import com.wm.javaoop.day1.Demo; public class Test{ public static void main(String[] args) { new Demo(); new com.wm.javaoop.day2.Demo(); String s="abc"; } }
注:import 导入其他包中的类,在一个类中需要用到另一个包中的类时,需要先导入全类名;(导包)
使用两个不同包里的类时,需要使用全类名;
java.lang包下的类在使用时不需导入就可以使用;(String)
访问权限修饰符
public
公共权限修饰类、属性、方法。可以被任意类访问;
protected
受保护的权限修饰属性、方法;可以被同包类访问,如果不是同包类,必须是该类的子类才可以访问;
默认
同包权限 修饰类、属性、方法。只能被同包的类访问
private
私有权限 修饰属性、方法。 只能在本类中访问
package com.wm.javaoop.day1; public class Demo { public int pub;//公共权限 修饰类、属性、方法;任意类访问 protected int pro;//受保护权限 修饰属性、方法;同包类访问、不同包类的子类 int num;//默认权限(同包权限) 修饰类、属性、方法;同包类 private int pri;//私有权限 修饰属性、方法;只能在本类中访问 public void putMethod(){ } protected void proMethod(){ } void Method(){ } private void priMethod(){ } public static void main(String[] args) { Demo demo=new Demo(); demo.pub=10; demo.pro=20; demo.num=30; demo.pri=40; } }
面向对象特征
三大特征
封装 继承 多态
封装
指的是通过权限修饰符,使得类中的信息是否对外可见(隐藏类中的信息)
设计模式:一系列解决问题的方案 算法
23种;
单例设计模式:解决只让一个类在一个程序中创建一个唯一的对象;
public class Person { private String name; private int age; private static Person person=null; private Person(){ } public static Person creatPerson(){ if(person==null){ person=new Person(); } return person; } //为封装起来的成员变量提供一个特定的公共权限的方法,用来为其赋值; //方便我们自己加入一些控制语句; public void setName(String name){ if(name!=null||name.length()<10){ this.name=name; } } //获取name属性值; public String getName(){ return this.name; } public void setAge(int age){ this.age=age; } public int getAge(){ return this.age=age; } }
public class TestPerson { public static void main(String[] args) { // Person zs=new Person(); // Person zs1=new Person(); Person zs=Person.creatPerson(); Person zs1=Person.creatPerson(); System.out.println(zs); System.out.println(zs1); } }