目录
this关键字
在编程时，为了区分成员变量和局部变量，在编码时，可以使用this关键字进行提示，
使用this调用的是成员变量或者成员方法，还有构造方法
this在实际的运行时，表示当前正在调用此方法的对象
this表示当前对象
代码部分
package day2.thisdemo;
public class Student {
int number;
String name;
String gender;
public Student(){
//赋予一些默认值
this(102,"李四","女");
}
public Student(int number,String name,String gender){
this.number = number;
this.name = name;
this.gender = gender;
}
public void study(){
System.out.println(this.name+"好好学习");
this.exam();
}
//就近原则：找最近的D变量
public void exam() { System.out.println(name+"认真考试");
}
}
package day2.thisdemo;
public class TestStudent {
public static void main(String[] args) {
Student student = new Student(100,"张三丰","男");
System.out.println(student.number);
System.out.println(student.name);
System.out.println(student.gender);
Student student1 = new Student(101,"月月","女");
System.out.println(student1.number);
System.out.println(student1.name);
System.out.println(student1.gender);
student.study();
student1.study();
student.exam();
student1.exam();
student.study();
//无参
new Student();
}
}
this调用成员变量图示
this调用方法图示
this调用构造方法图示
static关键字
概念
static表示静态，可以修饰成员变量，成员方法，代码块，内部类
类--class--静态代码 只有一份的存在
静态表示--在内存中只有一份的存在
static修饰成员
特点
static修饰的变量就是静态变量（类变量，与类一样，只有一份）
当所以类的对象的某一个属性值相同时，可以把他定义为静态的
当类被加载时，静态的成员就会被加载，先于对象创建存在
静态的先执行，可以被类，对象访问，非静态的只能通过对象访问
实例
package day2.staticdemo;
public class Chinese {
String name;
static String country = "中国";
public static void main(String[] args) {
Chinese chinese1 = new Chinese();
chinese1.name = "张三";
Chinese chinese2 = new Chinese();
chinese2.name = "里斯";
Chinese.country = "中国人";
System.out.println(Chinese.country);//静态成员因为在内存中只有一份，所以建议直接使用类名进行访问
System.out.println(chinese1.country);
System.out.println(chinese2.country);
}
}
static修饰方法
特点
static 关键字修饰的方法就是静态方法，属于类，我们可以通过类名直接访问
当方法中不需要使用非静态的成员变量时候，我们可以将这个方法设计为静态方法，不需要创建对象，直接通过类名访问
package day2.staticdemo;
public class Staticdemo {
String namtae;
static String country = "中国";
public static void test1(){
//System.out.println(name);在静态方法时，不能使用非静态的成员,因为静态的成员变量随着类的加载而加载，类加载优于对象
System.out.println(country);
}
/*
非静态成员方法中，可以使用静态成员变量，因为静态的变量先加载
*/
public void test(){
System.out.println(country);
}
public static void main(String[] args) {
Staticdemo.test1();
}
}
总结
static修饰后的成员，随着类的加载而加载
先于对象而存在
static修饰的成员变量在内存中只有一份，适合将所有实例都相同的属性设计为静态（中国人类 国籍都是人类）
静态的成员可以使用类名/对象名调用，一般建议使用类名访问
static修饰方法
静态方法只能访问静态的变量，不能访问非静态的变量
在方法中不使用非静态成员变量时，可以将方法设计为静态
public int max(int a,int b){
return (a>=b)?a:b;
}
代码块
概念
定义在类中，类似于一个没有名字的方法，
分为实例代码块
静态代码块
因为代码块没有名字，只能在满足条件时，自动由系统调用
1、 实例代码块
{
}
2、静态代码块
static{
}
实例代码块：在创建对象时，被自动调用执行
静态代码块：在类被加载时，被自动的调用执行
类什么时候被加载
通过类名访问类中静态成员时，类会被加载
当一个类中使用main方法，也会加载类
创建对象也会加载类
类只被加载一次
注意：如果有多个实例代码块或多个静态代码块，他们会按照先后顺序执行
实例代码块先于构造方法执行
代码
package day2;
public class demo {
{
System.out.println("Demo实例代码块1");
}
{
System.out.println("Demo实例代码块2");
}
public demo(){
System.out.println("demo类构造方法");
}
static {
System.out.println("Demo静态代码块1");
}
static {
System.out.println("Demo静态代码块2");
}
public static void test(){
System.out.println("静态test");
}
public static void main(String[] args) {
}
}
package day2;
public class TestDemo {
public static void main(String[] args) {
//demo.test();
//demo.test();
new demo();
new demo();
}
}
运行结果展示
包
问题：
项目越写类越多，难免可能会出现同名的类（java.util.Date,java.sql.Date）
不同类功能不同，需要分类管理
包：
为了解决一些类管理的问题，java引入包机制来解决
包称为类的命名空间（可以理解为是一个文件夹）
是类名的组成部分
类名（全类名=包名（地址）+类名简称
day1.demo2.Car
示例：
package com.ffyc.javaopp.day2;
import com.ffyc.javaopp.day1.demo2.Car;
import java.util.Date;
//import java.sql.Date;不能一次导入两个名称相同不同包的类
public class Pdemo {
public static void main(String[] args) {
new Date();
new java.sql.Date(10);
new Car();
new com.ffyc.javaopp.day1.demo3.Car();
}
}
作用：
一个类属于不同的包，就可以避免同名类问题
按照不同的功能管理类（web层，service逻辑处理，dao数据管理访问层）
控制访问权限
命名规范：
包名单词全部小写
包命名：
第一级，项目类型 com,org,gov,edu......
第二级，公司名称 oracle,sun,huswei,ali,ffyc.....
第一级，项目名称 oa,erp,cms.....
第四级，功能模块名称 .....
导入外部包的类，关键字”import"
当在一个类中使用其他包中的类时，需要先使用impor关键字导入进来(全类名)
只有Java.lang包中的类比较特殊，使用时不需要导入
访问权限修饰符
概念：
访问权限修饰符，用来修饰类中的成员，控制是否可以被访问
从大到小
public：公共权限，在系统中哪里都可以访问
修饰类（包含内部类），方法（构造方法，成员方法），成员变量
protected：受保护权限，在本类，同包类，不同包子类中可以访问
修饰内部类，方法（构造方法，成员方法），成员变量
：默认权限，在本类，同包类访问
修饰类（包含内部类），方法（构造方法，成员方法），成员变量
private：私有权限 只能在本类中使用
修饰内部类，方法（构造方法，成员方法），成员变量
代码示例：
正常类，可以使用public和默认权限
public修饰在任何包中都可以被访问
默认权限，只能在本包中的类使用
package com.ffyc.javaopp.day2.limitdemo1;
public class Person {
public int pubnum;//公共权限，在任何地方都可以访问
protected int pronum;//受保护权限，只能在本类，同包的其他类中使用，不同包的子类
int defnum;//默认权限，只能在本类，同包的其他类中使用
private int prinum;//私有权限，只能在本类中使用
public void test(){
}
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.pubnum);
System.out.println(p.pronum);
System.out.println(p.defnum);
System.out.println(p.prinum);//私有权限在本类中都可以访问
}
}
package com.ffyc.javaopp.day2.limitdemo1;
import com.ffyc.javaopp.day2.limitdemo1.Person;
public class TestPerson {
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.pubnum);
System.out.println(p.pronum);
System.out.println(p.defnum);
//System.out.println(p.prinum);
}
}
package com.ffyc.javaopp.day2.limitdemo2;
import com.ffyc.javaopp.day2.limitdemo1.Person;
import com.ffyc.javaopp.day2.limitdemo2.Student;
public class Test {
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.pubnum);
//System.out.println(p.pronum);
//System.out.println(p.defnum);
//System.out.println(p.prinum);
}
}
package com.ffyc.javaopp.day2.limitdemo2;
import com.ffyc.javaopp.day2.limitdemo1.Person;
public class Student extends Person {
public static void main(String[] args) {
System.out.println(new Student().pronum);
System.out.println(new Student().pubnum);
System.out.println(new Student());
}
}
面向对象特征---封装
含义：
1、包装，例如我们将一些常用的功能进行抽取，定义成一个方法
2、面向对象特征中的封装：隐藏，对类中的成员对外是否可见进行控制
封装案例1：将类中属性私有化
代码
package com.ffyc.javaopp.day3.fz;
public class Person {
/*
将成员变量设置为私有权限，在其他类中就不能直接访问
*/
private String name;
private int age;
public Person(){
}
//提供公共权限构造方法，外部可以通过构造方法对私有成员进行赋值
//但是需要使用成员变量的值时，就不能获取到
public Person(String name,int age) {
if(name.length() > 2 && name.length() < 5){
this.name = name;
}
if(age >= 0 && age < 150){
this.age = age;
}
}
//给私有属性对外提供的公共权限的方法进行赋值和值的获取
public void setName(String name){
if(name.length() > 2 && name.length() < 5){
this.name = name;
}
}
public String getName(){
return this.name;
}
public void setAge(int age){
if(age >= 0 && age < 150){
this.age = age;
}
}
public int getAge(){
return this.age;
}
}
package com.ffyc.javaopp.day3.fz;
public class Test {
public static void main(String[] args) {
//Person person = new Person("aaaaaaaaaa",2222222);
//在外部没有办法赋值时进行控制
//person.name = "aaaaaaaaaaaaa";
//person.age = 22222222;
Person p = new Person();
p.setName("chh");
p.setAge(20);
System.out.println(p.getName());
System.out.println(p.getAge());
}
}
package com.ffyc.javaopp.day3.fz;
public class Car {
private String name;
private String color;
private int age;
//给私有属性对外提供操作的公共方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
代码展示
封装案例2：将某些方法私有化
java设计模式（模板，固定套路 ）
解决一类问题的固定方式
单例模式：单个实例，在系统中，想让某个类只能创建一个对象
代码
package com.ffyc.javaopp.day3.fz;
public class MyWindow {
static int num = 0;
static MyWindow myWindow = null;
//将构造方法私有化，这样在其他类中，就无法使用构造方法，就不能创建对象
private MyWindow(){
}
//对外提供的获取位移对象的公共方法
public static MyWindow getMyWindow(){
if(myWindow==null){
myWindow = new MyWindow();
}
return myWindow;
}
}
package com.ffyc.javaopp.day3.fz;
public class TestMyWindow {
public static void main(String[] args) {
/*new MyWindow();
new MyWindow();
new MyWindow();
new MyWindow();*/
System.out.println(MyWindow.getMyWindow());
System.out.println(MyWindow.getMyWindow());
System.out.println(MyWindow.getMyWindow());
System.out.println(MyWindow.getMyWindow());
}
}
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
