Java对象与封装详解-优快云博客

一.匿名对象
定义:没有名字的对象.
意义:节省代码,并且很多情况下针对某个方法只需要调用一次的情况.
匿名对象可以调用方法,也可以给成员变量赋值.同时也可以作为方法的参数进行传递.
匿名对象的主要作用是节省代码量,使代码结构更加优化.
eg:public class Text2 {
public static void main(String[]args){
Person person=new Person();
person.name="Iron";
person.age=36;
person.speak(); //调用方法
new Person("badman",18).speak(); //匿名对象调用方法

}
}
class Person{
String name;
int age;
Person(){

}

Person(String nameParm,int ageParm){
name = nameParm;
age = ageParm;
}
void initPerson(Person person){

}
void speak(){
System.out.println("speak!:" +name + "." +age);
}
}
两者输出结果:
speak!:Iron.36
speak!:badman.18

二.封装
1.概念:隐藏对象的属性和细节,仅对外提供公共的方法进行访问.
2.private
a.当类的成员变量使用private修饰符修饰,那么就不可以直接访问到该成员变量.
b.当使用private修饰的成员变量或成员方法,仅能在本类中使用
c.private对于main方法的修饰,也是可以产生作用的.
eg:
public class Text4 {
public static void main(String[] args){
human person =new human();
person.name = "iron";
person.setAge(29);
person.eat();
person.action();
}

}
class human{
String name;
private int age;

void setAge(int ageParm){
if(ageParm>0 && ageParm<150){
age = ageParm;
}
}

void eat(){
System.out.println("eat");
}

void action(){
eat();
speak();
}

void speak(){
System.out.println("speak!: "+name+" . "+age);
}
}
JavaBean;
是这样的一类:
他的所有成员变量都是用private进行修饰,并且对外提供可访问的访问值和获取值set,get方法.
不同而应用场景,可能命名不同,数据库的应用中成为POJO类.
eg:public class Text5 {
public static void main(String[]args){
Teacher teacher=new Teacher();
teacher.setage(66);
teacher.speak();
}
}
class Teacher{
int age;
Teacher(){
}
void setage(int age){ //设置年龄
this.age=age;
}
int getage(){ //得到年龄
return age; //返回值
}
void speak(){
System.out.println(age);
}
}
课堂练习:自己定义一个手机类,定义他的两个值.通过调用方法输出
public class Demo1 {
public static void main(String[]args){
Phone phone1=new Phone();
phone1.setDianliang(98);
phone1.setxinghao("小米");
phone1.xianshi();

}
}
class Phone{
private int Dianliang;
private String xinghao;

void setDianliang(int DianliangParm){
Dianliang=DianliangParm;

}
int getDianliang(){
return Dianliang;
}
void setxinghao(String xinghaoParm){
xinghao=xinghaoParm;
}
String getxinghao(){
return xinghao;
}

void xianshi(){
System.out.println(xinghao+" "+Dianliang);
}
}
main方法细节:
a.每个类都可以存在main方法,但是当执行的时候,会优先查看public的class是否有main方法
b.如果没有public的class,会按照文件名优先查找类中的main方法
c.必须定义为public

三.优先原则
优先原则:对于一个类的成员方法来说,如果传递的形参的变量名称和类的成员变量名称相同,
jvm在处理的时候优先当做方法的形参来处理

四.this关键字
1.含义:
代表了当前对象的引用.可以理解为,当前谁来调用,那么方法中的this就代表谁.
对于成员变量可以区分出来的场景,this可加也可以不加,实际效果相同.
但是对于实现javaBean/POJO来说,我们建议都加上setXXX,getXXX方法中.
this:可以加在成员变量的前面来指定对应的引用,也可以加成员方法的前面.
课堂练习:
public class Demo2 {
public static void main(String[]args){
Person person=new Person();
person.setage(18);
person.setid(1502080223);
person.setname("雷锋");
person.speak();
}
}

class Person{
private int age;
private String name;
private int id;
Person(){

}
void setname(String name){ //设置名字
this.name=name; //这个名字等于当前的名字
}
String getname(){
return name;
}
void setage(int age){
this.age=age;
}
int getage(){
return this.age;
}
void setid(int id){
this.id=id;
}
int getid(){
return id;
}
void speak(){
System.out.println("年龄"+ age +"名字"+ name +"学号"+ id);
}
}
五.初始化类成员变量的方式
a.在定义方法成员变量的同时进行赋值.
//在构造方法执行前进行赋值,并且该类每个实现的对象,都会被初始化为该值.
//意义:当我们真的需要一个类的所有对象某些成员变量的值一致的时候.
Person person=new Person();
person.entity="Japan";
person.showEntity();
b.提供外界可访问到的方法,在方法中进行赋值.
//构造方法中直接进行赋值.
//意义:可以在创建对象的同时进行赋值,同时还在动态的指定设定的值是什么
Person peroson1 =new Person(40);
person1.showEntity();
c.通过构造方法进行赋值.
//通过调用某个设置值的方法进行赋值,在对象创建完成之后
//意义:动态的修改成员变量的值.
Person person2=new Person();
person2.showEntity();
例子:public class Text6 {
public static void main(String[]args){
Man man=new Man(); //第一种方式
man.entity="China";
man.showEntity();
System.out.println("--------------------------");
Man man1=new Man(60); //意义第二种方法
man1.showEntity(); //可以在创建对象的同时进行赋值,
//同时还可以动态的指定设定的值
System.out.println("--------------------------");
Man man2=new Man();
man2.showEntity();
}
}
class Man{
int age;
String entity;
Man(int age){
this.age=age;
}
public Man() {
// TODO Auto-generated constructor stub
}
void setAge(int age){
this.age=age;
}
int getAge(){
return age;
}
void eat(){
System.out.println("eat:"+this.age);
}
void outputAge(){
System.out.println(this.age);
}
void speak(){
System.out.println("speak!");
}
void showEntity(){
System.out.println("Entity:"+entity);
}
}
输出结果:
Entity:China
--------------------------
Entity:null
--------------------------
Entity:null
六.static
a.随着类加载而加载
静态方法去中来保存静态成员变量
b.优先于对象创建
Person.className="java";
c.被类的所有对象共享
静态的成员变量会保存在该class的静态方法区中,所以每个对象看到的都是同一份.
d.可以通过类名来访问也可以通过对象名来访问.
效果是一样的.
e.推荐通过类名来访问
f.静态的成员,一般称为类相关的成员.
static修饰符既可以修饰成员变量,也可以修饰成员方法.且修饰之后,就可以通过类名直接访问到.
g.this变量在静态方法中不可调用

h.静态方法中只能访问静态成员变量和静态方法.
非静态方法既可以访问静态成员和方法也可以访问非静态成员和方法.
非静态虽然可以访问静态的方法,但是不建议这么做.
eg:public class taxt7 {
public static void main(String []args){
Boos boos=new Boos();
Boos.action();
method();

}
static void method(){
System.out.println("method");
}
}
class Boos{
static String name="diffo";
static int age=20;
void speak(){
System.out.println("speak:"+age);
}
static void action(){

}
}

七.main方法
修饰符返回类型方法名(参数列表){
}
public static void main(String[]args){

}
public :最大的访问权限,使得jvm能够成功调用
static:类相关的,与对象无关.A.main([]);

public class A{
main(){
System.("");
}
}

void:不需要返回值.
方法名:main
参数列表:执行的时候,可以传递参数.
八.工具类.
全部都是静态的方法.所以可以通过类名.functionName()方式来访问.
一般来说,都会对默认构造方法进行私有化,来防止别人使用习惯性的创建对象来调用方法.
//工具类:都是把其中的方法定义为static
public class MathUtil{
//加法
static int(int num1,int num2){
return num1+num2;
}
//减法,乘法
private MathUtil(){

}
public static void main(String[]args){
System.out.println(MathUtil.sum(2,3));
new User().getResult();
}
}
class User{
void getResult(){
System.out.println(MathUtil.sum(2,3));
}
}
课堂练习
public class Text8 {

public static void main(String[]args){
Square square =new Square();
square.setLength(40);
System.out.println(SquareUtil.getCircumLength(square));
System.out.println(SquareUtil.getArea(square));
}
}
class Square{
private int length;
void setLength(int length){
this.length=length;
}
int getLength(){
return this.length;
}
}
class SquareUtil{
private SquareUtil(){
}
static int getCircumLength(Square square){
return 4*square.getLength();
}
static int getArea(Square square){
return square.getLength()*square.getLength();
}
}
输出结果
160
1600