day02_java基础加强(jdk新特性 javaa设计模式反射)

来源：互联网发布：云端网络趋势编辑：程序博客网时间：2024/06/15 16:18

1.Tcp协议发送数据

当使用tcp发送数据的时候必须的有服务器端,当第一次执行客户端代码会报如下错误

java.net.ConnectException: Connection refused: connect 连接被拒绝

代码实现

[1]客户端代码

public class Client {
 
public static void main(String[] args) throws Exception{
 
//1.创建socket的实例 
Socket socket = new Socket(InetAddress.getByName("192.168.126.26"),9999);
String data = "tcp我来了";
//2.返回此套接字的输出流。通过输出流向服务器发送数据 
socket.getOutputStream().write(data.getBytes());
//3.关闭socket
socket.close();
}
 
}

[2]服务器代码

public class ServerClient {
 
public static void main(String[] args) throws Exception{
 
//1.创建serversocket对象 
ServerSocket ss = new ServerSocket(9999);
//2.侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。  这个对象其实就是发送端的socket对象
Socket socket = ss.accept();
//3.获取客户端发送的数据  要使用输入流 
InputStream is = socket.getInputStream();
//4.把数据读取出来 
int len =0;
byte buf[] = new byte[1024]; 
while((len = is.read(buf))!=-1){
String str = new String(buf,0,len);
System.out.println("服务器:"+str);
}
ss.close();

}
 
}

2.客户端发送数据数据来自键盘录入

public class Client {
 
public static void main(String[] args) throws Exception{
 
//1.创建socket的实例 
Socket socket = new Socket(InetAddress.getByName("192.168.126.26"),9999);
//String data = "tcp我来了";
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext()){
String data = scanner.nextLine();
 
//1.1 当用户输入的是886 跳出while循环
if ("886".equals(data)) {
break;
}
//2.返回此套接字的输出流。通过输出流向服务器发送数据 
socket.getOutputStream().write(data.getBytes());
}
scanner.close();
//3.关闭socket
socket.close();
}
 
}

3.文件上传核心逻辑

朋友圈,百度网盘 360云盘.邮箱-->上传附件

代码实现:

[1]客户端代码

public class Client {
 
public static void main(String[] args) throws Exception{
 
//1.创建socket的实例 
Socket socket = new Socket(InetAddress.getByName("192.168.126.26"),9999);
//2.先读取abc.txt文件内容 
FileInputStream fis = new FileInputStream("abc.txt");
int len=0;
byte buf[] = new byte[1024];
while((len=fis.read(buf))!=-1){
//2.返回此套接字的输出流。通过输出流向服务器发送数据 
socket.getOutputStream().write(buf, 0, len);
}
fis.close();
//3.关闭socket
socket.close();
}
 
}

[2]服务器代码

public class ServerClient {
 
public static void main(String[] args) throws Exception{
 
//1.创建serversocket对象 
ServerSocket ss = new ServerSocket(9999);
//2.侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。  这个对象其实就是发送端的socket对象
Socket socket = ss.accept();
//3.获取客户端发送的数据  要使用输入流 
InputStream is = socket.getInputStream();
FileOutputStream fos =new FileOutputStream("abcd.txt");
//4.把数据读取出来  并写到指定文件中
int len =0;
byte buf[] = new byte[1024]; 
while((len = is.read(buf))!=-1){
fos.write(buf, 0, len);
}
fos.close();
ss.close();
}
 
}

总结 :客户端上传的是什么文件类型服务器接收的就应该是什么格式.

udp:datagramSocket DatagramPacket

tcp :socket serversockete

4.枚举(1.5)

枚举应用场景,比如我要定义一个星期(1-7)变量四季(春夏秋冬) 交通灯(红绿黄)

我使用一个普通类来模拟枚举的功能.

package com.itheima.enumtest;
 
//普通类 来模拟枚举功能   模拟星期
//枚举只能是固定的几个实例
public abstract class WeekDay {
 
//1.构造方法私有化
private WeekDay(){}
//2.自己创建几个实例 {}代表通过该类的子类完成实例化 就是实现父类为实现的方法
public static WeekDay mon = new WeekDay(){
 
@Override
public WeekDay nextDay() {
return sun;
}
};
public static WeekDay sun = new WeekDay(){
 
@Override
public WeekDay nextDay() {
return mon;
}
};
//3.定义一个方法 nextDay   //Perosn   
/*public WeekDay nextDay(){
if (this == mon) {
return sun;
}else if (this == sun) {
return mon;
}else {
return null;
}
}*/
//4.为了简化if else 语句    我这样定义 
public abstract WeekDay nextDay();
//3.默认打印实例 打印地址  重写toString方法  alt + shift + s
@Override
public String toString() {
if (this == mon) {
return "mon";
}else  if (this == sun) {
return "sun";
}else{
return "";
}
}
}

如何定义枚举. class interface enum 实现带抽象方法的枚举

public enum Weekday {
 
// 这个成员默认是静态:
SUN, MON(2), TUE, WED, THRI, FRI(50), SAT;
// 1.定义构造方法
private Weekday() {
System.out.println("1111");
}
 
//2.定义一个带参数的构造方法
private Weekday(int day) {
System.out.println("22222");
}
 
}

带抽象方法的枚举

public enum TrafficLamp {
 
RED{
 
@Override
public TrafficLamp nextLamp() {
return TrafficLamp.GREEN;
}
},GREEN{
 
@Override
public TrafficLamp nextLamp() {
return YELLOW;
}
},YELLOW{
 
@Override
public TrafficLamp nextLamp() {
return TrafficLamp.RED;
}
};
//定义下一个灯
public abstract  TrafficLamp nextLamp();
}

5.单例设计模式

单例设计模式特点: 在内存中只有一个实例存在.

5.1饿汉式代码写法

//想保证student对象在内存中只有一个实例 
//单例设计模式分类 饿汉式 懒汉式
public class Student {
 
//1.构造方法私有化 
private Student(){}
//2.自己创建一个实例    李四
private static Student s = new Student();
//3.对外提供一个获取实例的方法 
public static Student getStudent(){
return s;
}
}

5.2 懒汉式代码写法

public class Teacher {
 
//1.构造方法私有化 
private Teacher(){}
//2.自己先不创建  先声明 
private static Teacher t;
//3.提供一个方法获取teacher的实例  t1 t2 t3
public synchronized static Teacher getTeacher(){
if (t == null) {
t = new Teacher();
}
return t;
}
 
}

6.工厂设计模式

工厂设计模式可以负责对象的创建对实例创建进行封装.

代码实现过程

1.先定义一个猫和狗的实例

//定义一个猫类
public class Cat extends Anim{
 
//提供一个吃的方法  
public void eat() {
System.out.println("鱼");
}
}

//定义一个狗 类
public class Dog extends Anim{
 
//提供一个吃的方法
public void eat() {
System.out.println("肉");
}
}

2.由于猫和狗都是动物所以向上抽取了一个动物类

//抽象一个动物类 提供一个吃的方法
public abstract class Anim {
 
public abstract void eat();
}

3.创建一个工厂这个工厂负责猫和狗对象的创建

//这个类就负责猫和狗的创建
public class AnimFactory {
 
//1.不需要提供new对象的方式获取工厂的实例 所以构造方法私有化   
private AnimFactory(){};
//2.对外提供一个创建猫和狗实例的方法 参数代表 获取动物的类型 
public static Anim getAnim(String type) {
if ("dog".equals(type)) {
return new Dog();
}else if ("cat".equals(type)) {
return new Cat();
}else {
return null;
}
 
}
}

7.模板设计模式

代码实现过程

1.定义一个计算时间模板

public abstract class GetTime {
//获取一段逻辑执行需要的时间  这个方法相当于是一个计算时间的模板
public long  getCodeTime(){
//1.获取当前系统的时间 
long startTime = System.currentTimeMillis();
code();  //具体要计算 的业务逻辑让子类去实现
//2.在获取一下系统时间
long endTime = System.currentTimeMillis()-startTime;
return endTime;
}
public abstract void  code();
 
}

2.定义for循环执行1000万次需要的时间

public class GetForTime extends GetTime {
 
@Override
public void code() {
//1.1 算出 for循环 需要多长时间 
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
}
 
}

3.定义拷贝视频的逻辑

public class GetCopyVideoTime extends GetTime {
 
@Override
public void code() {
 
//这里写拷贝视频的逻辑
 
//1.2 算出拷贝一段视频需要多长时间  
try {
FileInputStream fis = new FileInputStream("test.avi");
FileOutputStream fos = new FileOutputStream("copy.avi");
//流对接操作 
int len =0;
byte[] buf = new byte[1024];
while((len=fis.read(buf))!=-1){
fos.write(buf, 0, len);
}
fis.close();
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
 
}

8.适配器设计模式

代码实现过程

1.定义一个接口接口里面有4个方法

 
public interface User {
 
public void add();
public void del();
public void update();
public void query();
}

2.定义一个适配器类 Adapter 默认实现这个接口

public class Adapter implements User {
 
@Override
public void add() {
}
 
@Override
public void del() {
 
}
 
@Override
public void update() {
 
}
 
@Override
public void query() {
 
}
 
}

3.定义一个具体的实现类来继承Adapter类用到哪个方法就重写哪个方法

public class UserImp2 extends Adapter {
 
@Override
public void add() {
super.add();
}
}

9. 装饰设计模式

去4s店买个车宝马x5 买房毛坯房手机(诺基亚) 打电话.

代码实现过程

1.定义一个接口接口里面有个一个打电话功能

public interface Phone {
 
public void call();
}

2.向上抽取了一个基本的装饰类基本的装饰类要保证有通话功能

 
public abstract class BaseDecorate implements Phone {
 
//子类在装饰的时候 要保证有基本的通话功能 
private Phone p;
public BaseDecorate(Phone p){
this.p = p;
}
@Override
public void call() {
 
this.p.call();
}
 
}

3.在定义具体的装饰类比如播放音乐加彩铃

public class MusicDecorate extends BaseDecorate {
 
public MusicDecorate(Phone p) {
super(p);
}
@Override
public void call() {
super.call();
System.out.println("手机可以听音乐了");
}
 
}

4.定义一个测试类就可以了

public class TestPhone {
 
public static void main(String[] args) {
//1.手机可以通话了
Iphone iphone = new Iphone();
iphone.call();
System.out.println("-------------");
//2.对手机进行装饰  加彩铃  播放音乐  播放视频 不管对手机怎么装饰 都要保证电话的基本功能
RingDecorate ringDecorate = new RingDecorate(iphone);
ringDecorate.call();
System.out.println("---------***----");
//3.对iphone继续装饰  加音乐
MusicDecorate musicDecorate = new MusicDecorate(iphone);
musicDecorate.call();
 
}
 
}

总结设计模式:

1 单例(必须会)

2 工厂设计模式(必须会)

3 模板设计模式(了解)

4.适配器设计模式(必须会)

5.装饰设计模式(了解)

10.Class介绍

黑人白人黄人---->人宝马奥迪奔驰 QQ H6(油老虎)--->car String list Map .....>Class

一个Class里面应该有什么呢构造方法属性(成员) 方法

获取一个类的Class对象的三种方式:

public class TestClass {
public static void main(String[] args)  throws Exception{
String str = "abc";
//1.获取str 对应的Class对象 
    Class  class1 = str.getClass();//补充：需要写实例，麻烦
    //2.类名.class   只要是在java中你能想到的任何类型 都会有一份字节码对象
  
    Class  class2 = String.class;//还需要引个包
    
    //3.Class.forName(); 获取Class对象
    Class  class3 = Class.forName("java.lang.String");//所以一般用这个
    
    System.out.println(class1 == class2);
    System.out.println(class2 == class3);
    
    
}
 
}

11.反射

反射概念:反射就是把java中相应的成分(构造方法成员方法)映射成相应的类.

11.1获取person类中构造方法

//获取带私有的构造方法
private static void method2() throws Exception{
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 =  Class.forName("com.itheima.classtest.Person");
//2.获取person类中所有的构造方法 
Constructor[] declaredConstructors = class1.getDeclaredConstructors();
//3.遍历 
for (Constructor constructor : declaredConstructors) {
System.out.println(constructor);
}
}
 
//alt + shift + M 快速抽取一个方法    获取person类中构造方法 不包含私有的
private static void method1() throws ClassNotFoundException {
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 =  Class.forName("com.itheima.classtest.Person");
//2.获取person类中所有的构造方法 
Constructor[] constructors = class1.getConstructors(); //私有获取不到
//3.遍历数组
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
}

11.2获取person类中单个空参构造方法并且实例化

//获取person类中 public Person(){};
private static void method3() throws Exception{
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 =  Class.forName("com.itheima.classtest.Person");
//2.获取 public Person(){};构造方法  参数:可变参数
Constructor constructor = class1.getConstructor();  //这个类的实例就代表构造方法
//3.通过构造方法获取person的实例
Object object = constructor.newInstance();
System.out.println(object);
}

11.3获取person类中单个带参构造方法并且实例化

//获取person类中单个带参构造方法并且实例化
private static void method4() throws Exception{
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 =  Class.forName("com.itheima.classtest.Person");
//2.获取 public Person(String name,int age,String address);
Constructor constructor = class1.getConstructor(String.class,int.class,String.class);
//3.通过构造方法获取person的实例
Object object = constructor.newInstance("zhaowei",20,"沙河");
System.out.println(object);
}

11.4获取person类中私有的构造方法

//获取person类中私有的构造方法
private static void method5() throws Exception{
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 =  Class.forName("com.itheima.classtest.Person");
//2.获取私有的构造方法 private  Person(String name)
Constructor constructor = class1.getDeclaredConstructor(String.class);
//3.暴力反射 其实就是调用一个方法  值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查
constructor.setAccessible(true);
//3.通过构造方法获取person的实例
Object object = constructor.newInstance("柳岩");
System.out.println(object);
}

11.5 获取person类中成员(属性并且使用)

// 获取所有的属性 包括私有的
private static void method2() throws Exception{
// 1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
// 2.获取person类中所有的属性 
Field[] declaredFields = class1.getDeclaredFields();
//3.遍历
for (Field field : declaredFields) {
System.out.println(field);
}
}
 
// 获取person类中所有的属性
private static void method1() throws Exception {
// 1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
// 2.获取person类中所有的属性 (不要考虑私有)
Field[] fields = class1.getFields();
// 3.遍历
for (Field field : fields) {
 
System.out.println(field);
}
 
}

11.6获取单个属性并且使用

//获取person类中address属性并且
private static void method3() throws Exception{
// 1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person"); 
//2.获取address属性并且使用 参数:获取哪个属性
Field field = class1.getField("address");
//3.通过构造方法获取person的实例 
    Constructor constructor = class1.getConstructor();
Object obj = constructor.newInstance();
System.out.println("---"+obj);
//3.给address属性赋值  参数1:代表person的实例
field.set(obj, "上海");
System.out.println(obj);
}

12.今天总结

1.tcp协议了解 ☆

2.枚举 ☆☆☆

3.单例 ☆☆☆

4.工厂 ☆☆☆

5.适配器 ☆☆☆

6.模板 ☆☆

7.装饰 ☆

8.Class类 ☆☆☆

9.反射 ☆☆☆

复习：

1.枚举：（具体见day2——4）

原理模拟：枚举就是一个把构造方法私有的抽象类。

私有构造方法是为了不让别人通过new随意建立对象，而只能通过类名调用在本身已经定义好的对象（所以在本类中新建对象时必须用static修饰）。

抽象是为了方法实现。

方法实现：先在本类中定义一个抽象方法，新建对象时通过加{匿名内部类类型的子类}实现抽象方法。

2.单例设计模式：（day2——5）

原理：

懒汉式：私有化构造，直接new对象，对外提供获取方法；

饿汉式：私有化构造，先定义对象，但是不初始化。在获取方法里面判断对象是否为空，为空再新建。

（饿汉式容易出现线程安全问题，获取方法上要加synchronize，一般不用饿汉式，两种方法的构造都要加static，因为要让外界直接调用）

3.工厂设计模式：（day2——6）

原理：抽取各个对象类的共性，建立一个抽象的父类，再用一个工厂对调用方法加工（工厂获取客户需求，内部调用对象并反馈）。

4.模板设计模式：

原理：做一个模板，用子类继承模板，并覆盖部分方法，以实现特殊功能。

5.适配器设计模式：

原理：先做一个接口，然后用一个适配器实现接口中所有的方法，但是方法的内容为空，当有需要用到这些方法的时候，再新建一个类继承适配器并覆盖

需要用到的方法

6.反射：

原理：反射就是把java中相应的成分(构造方法成员方法)映射成相应的类.

1. 构造方法反射成 constructor类

① 获取单个用getConstructor(参数类型.参数名如：原构造是 String a 在这里变为---> String.class)方法，获取多个用getConstructor

② 如果要获取私有的，用getDeclaredConstructors(),

getDeclaredConstructor(参数类型.class,...）如：原构造是 String a 在这里变为---> String.calss

私有需要暴力反射： constructor.setAccessible(true);

例子：演示获取空参构造并实例。（里面是可以加参数的，下面的例子是空参的例子。）

Constructor constructor = class1.getConstructor();

                    Object obj = constructor.newInstance();实例化

2. 成员反射成 field类

① 获取单个用getField(里面加需要获取的成员名，+加引号)方法，获取多个用getFields

② 如果要获取私有的，用getDeclaredFields(),getDeclaredField("成员名")

获取单个并实例化，用

1.获取空参构造实例。

Constructor constructor = class1.getConstructor();

                      Object obj = constructor.newInstance();
                                     2.通过set，给空参实例赋值成员属性。
                              field.set(obj, "上海");
                       System.out.println(obj);

3. 方法反射成 method类

同上： getDeclaredMethod，getDeclaredMethods,getMethod，getMethods

12.今天总结

1.tcp协议了解 ☆

2.枚举 ☆☆☆

3.单例 ☆☆☆

4.工厂 ☆☆☆

5.适配器 ☆☆☆

6.模板 ☆☆

7.装饰 ☆

8.Class类 ☆☆☆

9.反射 ☆☆☆

阅读全文

0 0

day02_java基础加强(jdk新特性 javaa设计模式 反射)

1.Tcp协议发送数据

2.客户端发送数据 数据来自键盘录入

3.文件上传核心逻辑

4.枚举(1.5)

5.单例设计模式

6.工厂设计模式

7.模板设计模式

8.适配器设计模式

9. 装饰设计模式

10.Class介绍

11.反射

1.枚举：（具体见day2——4）

2.单例设计模式：（day2——5）

3.工厂设计模式：（day2——6）

4.模板设计模式：

5.适配器设计模式：

6.反射：

day02_java基础加强(jdk新特性 javaa设计模式反射)

2.客户端发送数据数据来自键盘录入