第二周 3.4.5java周总结
1 匿名对象
匿名对象:没有名字的对象
匿名对象的格式
new 类名() ; (前提条件:该类是一个具体类)
特点:
1.仅仅使用一次,使用完毕,从内存中会立即被释放掉! (节省内存空间,android移动端使用居多!)
2.匿名对象也可以作为参数进行传递
注意:
在使用匿名对象的时候,建议不使用多次
例
自定义一个学生类
class Student{
public void study(){
System.out.println("好好学习,天天向上!!") ;
}
}
//自定义StudentDemo类
class StudentDemo{
public void method(Student s){//形式参数是一个引用类型,具体类
s.study() ;
}
}
//测试类
class NoNameDemo{
public static void main(String[] args){
//需求:访问StudentDemo类中的method方法
//创建StudentDemo类对象 类名 对象名 = new 类名() ;
StudentDemo sd = new StudentDemo() ;
//创建学生类对象
Student s = new Student() ; //对象名称叫s (有名称的对象)
sd.method(s) ;
System.out.println("-------------------------")
//使用匿名对象
sd.method(new Student()) ; //该学生的匿名对象作为参数传递
System.out.println("-------------------------") ;
//链式编程(开发中不建议这样使用,阅读性差,建议分开写)
new StudentDemo().method(new Student()) ;
}
}
2 封装
2.1 private关键字
private关键字的特点:
1)private可以修饰一个类中的成员变量,也可以成员方法
2)被private修饰的成员变量或者是成员方法只能在本类中方法,外界不能访问的!(保证数据的安全性)
举例说明
class Demo{
//定义一个成员变量
int num = 10;
private int num2 = 30 ; //私有修饰,只能在Demo类中访问,外界要访问需要通过公共的方法来访问!
//成员方法
public void method(){
System.out.println(num) ;
System.out.println(num2) ;
System.out.println("method demo...") ;
}
//私有的成员方法
private void function(){ //私有的方法,只能在本类中访问
System.out.println("function demo...") ;
}
//公共方法
public void show(){
function() ;
}
}
//测试类
class PrivateDemo{
public static void main(String[] args){
//创建Demo类的对象
Demo d = new Demo() ;
d.num = 50 ; //num成员变量在Demo类中没有被private修饰
System.out.println(d.num) ;
//d.num2 = 100 ; //System.out.println(d.num) ;
//System.out.println(d.num2) ;
System.out.println("-------------------------") ;
d.method() ;
//d.function() ;// function() 在 Demo 中是 private 访问控制
d.show() ;
}
}
2.2 一个标准类的写法
之前:标识符给变量/方法起名字,都要见名知意
当前学生类中的setName(String n),还有setAge(int a),变量n和a都不太合适
给学生赋值姓名 :name和年龄:age
按照上面这种方式改造---->局部变量和成员变量名称一样(局部变量隐藏了成员变量)
----为了区分成员变量和局部变量----java提供了一个关键字:this(代表了当前该类对象地址引用)
setXXX(形参)方法,谁调用这个方法,那么this代表它(地址)
一个标准类的写法
Phone 类
属性:品牌(brand),价格(price),颜色(color) ----->属性私有化
提供公共setXXX(形式参数)getXXX()方法
行为:打电话,发短信,游戏
改造成标准类的写法
//定义一个学生类
class Student{
//成员变量私有化
private String name ; //姓名
private int age; //年龄
//提供公共的访问方法赋值 setXXX/getXXX方法 XXX对应的属性名称
//给姓名赋值
/*
public void setName(String name){
name = name ;
}
*/
//改进
public void setName(String name){ //"李四"
this.name = name ;//this.name = "李四"
}
/*
//给年龄赋值
public void setAge(int age){
age = age ;
}
*/
public void setAge(int age){ // age = 25 局部变量
this.age = age ; //this.age = 25
}
//获取姓名
public String getName(){
return name ; //此时获取的name,成员变量的name,隐藏关键了this
//return this.name ; //其实这样的写法 //return "李四" ;
}
//获取年龄
public int getAge(){
return age ;// return this.age = return 25 ;
}
//其他的成员方法:
public void study(){
System.out.println("学习Java中的面向对象...") ;
}
}
//测试类名
class StudentTest{
public static void main(String[] args){
//创建学生类对象
Student s = new Student() ;
//通过setXXX方法进行赋值
s.setName("李四") ;
s.setAge(25) ;
System.out.println(s.getName()+"---"+s.getAge());
s.study();
}
}
3 关键字 static
3.1 static(静态修饰符)的特点:
1)被static修饰的变量/方法 都随着类的加载而加载
class xxx{} ----> 通过javac 编译xxx.java文件 --->编译没有问题(Java语法校验)
---->产生xxx.class文件
java xxx类
2)被static修饰的 优先于对象存在
回想main :被静态修饰符: jvm调用它
public static void main(String[] args){
}
3)被static修饰的可以被多个对象共用
4)被静态修饰的成员变量或者成员方法,
可以被类名直接访问(推荐访问方式)
类名.成员方法;
类名.成员方法();
但是,也可以用该类对象来访问该成员(不推荐的!)
举例说明:
静态修饰符在成员变量中的用法
class Demo{
//成员变应量
int num = 100 ;
//静态成员变量
static int num2 = 50 ;
//成员方法
public void show(){
System.out.println("show Demo") ;
}
//静态的成员方法
public static void method(){
System.out.println("method Demo") ;
}
}
//测试类
class StaticDemo{
public static void main(String[] args){
Demo d = new Demo() ;
//访问非静态的成员变量,成员方法
System.out.println(d.num) ;
d.show();
System.out.println("-------------") ;
//对象名来访问静态成员
System.out.println(d.num2) ;
d.method();
System.out.println("-------------") ;
//推荐方式:静态成员 直接使用类名访问(static静态的随着类的加载而加载)
System.out.println(Demo.num2) ;
Demo.method();
}
}
3.2 static 用法的注意事项
使用static关键字的注意事项:
1)在static中,是没有this关键字的! (this:代表当前类的对象的地址值,对象已经创建了而static修饰的
和类有关系);
2)关于成员方法的访问问题:
非静态的成员方法
既可以访问静态的成员变量,也可以访问非静态的成员变量
既可以访问静态的成员方法,也可以访问非静态的成员方法;
静态的成员方法
简单记:静态只能访问静
3.21 举例说明非静态的成员方法和静态的成员方法:
//自定义一个类
class Demo2{
//定义一个成员变量
int num = 100 ;
//静态成员变量
static int num2 = 200 ;
//成员方法
public void show(){
System.out.println(num2) ;
System.out.println(num) ;
}
//成员方法
public void method(){
show() ;
function() ;
}
//静态的成员方法
public static void function(){
System.out.println("这是静态的function方法...") ;
}
//静态的成员方法
public static void function2(){
System.out.println(num2) ;
//System.out.println(num) ; // 无法从静态上下文中引用非静态 变量 num
//show() ; 无法从静态上下文中引用非静态 方法 show()
function() ;
}
}
//测试
class StaticDemo2{
public static void main(String[] args){
//创建Demo2类的对象
Demo2 d = new Demo2() ;
d.show() ;
System.out.println("-------------------------") ;
d.method() ;
System.out.println("-------------------------") ;
d.function2() ;
System.out.println("-------------------------") ;
int result = sum(10,20) ; //静态只能访问静态!
System.out.println(result);
}
//求两个数据之和
public static int sum(int a,int b){
return a + b ;
}
}
4 面向对象的简单学习
在生活中 实例引用
需求:键盘录入长方形的长和宽,求面积和周长
分析:
长方形: ------ > 长方形类(ChangFangXing)
有两个属性:长和宽 length,width 成员变量
行为:面积,周长 —>功能:成员方法 getZhouChang() getArea()
代码:
//导包
import java.util.Scanner ;
//定义长方形类
class ChangFangXing{
//属性私有化
private int length ; //长
private int width ;//宽
public ChangFangXing(){
}
public void setLength(int length){
this.length = length ;
}
public void setWidth(int width){
this.width = width ;
}
//定义求周长和面积的成员方法
public int getZhouChang(){
return (length+width)*2 ;
}
public int getArea(){
return length * width ;
}
}
//创建一个测试类
class Test2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
System.out.println("请输入长方形的长:") ;
int length = sc.nextInt() ;
System.out.println("请输入长方形的宽:") ;
int width = sc.nextInt() ;
//创建长方形类的对象
ChangFangXing
cfx = new ChangFangXing() ;
cfx.setLength(length) ;
cfx.setWidth(width) ;
System.out.println("该长方形的周长是:"+cfx.getZhouChang()) ;
System.out.println("该长方形的面积是:"+cfx.getArea()) ;
}
}